java中线程安全类有哪些 java常用线程安全类

Java线程安全与程序性能

定义

线程安全:当多个线程访问某个类的时候,不管运行时采用何种调度方式或者这些线程如何交替执行并且在
这主调代码中不需要任何额外的同步和协同,这个类都能表现出正确的行为, 那么就称这个类为线程安全.


    并发:并发当有多个线程在操作时,如果系统只有一个CPU,则它根本不可能真正同时进行一个以上的线程，
它只能把CPU运行时间划分成若干个时间段,再将时间 段分配给各个线程执行，在一个时间段的线程代码运行时
，其它线程处于挂起状。

简单说明

线程安全可能是非常复杂的,在没有足够的同步下,多线程执行的顺序是不可预测的,如下在单线程执行时没有任何问题的, 但是多线程执行时可能会出现两个或者多个值一致.

public class Unsafe {

    int a=0;
    public int getA(){
        return a++;
    }

}

因为在多个线程并发中, 对a++进行操作需要三步:读-改-写,首先在主存中读取a的值进入线程工作内存中,然后对a进行++操作, 最后写回主存中.假设线程1,2,3读取a的值都为10,那么线程1,2,3得到a++的值都会是11,因为这个过程中程序都是并行执行, 并不是串行.
以上最简单的解决方式就是在int前面加上隐式同步锁synchronized,但是这种方式并不高效,每个线程需要执行a++操作, 都需要获取Unsafe实例的锁, 竞争锁失败的线程都会被JVM系统挂起,线程1切换至线程2,我们称之为上下文切换, 这种行为需要系统内核到底层把线程2唤醒, 开销太大.有没有更好方式解决这个问题,不需要劳烦到系统底层呢, 答案是有的,如下

private AtomicInteger mAtomicInteger=new AtomicInteger();
    private volatile int a=0;
    public Safe(){
        mAtomicInteger.set(a);
    }
    public int getA(){
        for(;;){

            if(mAtomicInteger.compareAndSet(mAtomicInteger.get(), mAtomicInteger.get()+1)){
                return mAtomicInteger.get();
            }
        }
    }

CAS(CompareAndSwap)是一种比较交换,通过循环来保证线程安全的乐观锁.竞争失败的线程并不会被系统挂起, 而是通过自旋(Self-Spin)不断竞争直到成功返回.

性能

主要从可伸缩性,(吞吐率(处理能力)),(服务时间, 延迟时间 (运行速度)) 展开~

**多线程性能需要建立线程安全基础上, 离开了线程安全线程性能变得没有意义.

Amdahl定律
S<=1/(1-a+a/n)

其中，a为并行计算部分所占比例，n为并行处理结点个数。这样，当1-a=0时，(即没有串行，只有并行)最大加速比s=n；当a=0时（即只有串行，没有并行），最小加速比s=1；当n→∞时，极限加速比s→ 1/（1-a），这也就是加速比的上限。例如，若串行代码占整个代码的25%，则并行处理的总体性能不可能超过4。这一公式已被学术界所接受，并被称做“阿姆达尔定律”。

根据Amdahl定律可知,程序性能是与串行,并行执行息息相关的,但是糟糕的程序设计并行会带来性能开销,不会提升性能如下说明

// 并行程序
public class Person {
    private static void sleep(long time){
        try{
            Thread.sleep(time);
        }catch (Exception e) {
            // TODO: handle exception
        }
    }
    public synchronized void takeATurnRound(){
        //run 
        sleep(1000*60*10);
    }
    public static void main(String[]arg){
        Person mPerson=new Person();
        ExecutorService mExecutorService = Executors.newCachedThreadPool();
         for(int i=0;i<3;i++){

             mExecutorService.submit(()->{
                 mPerson.takeATurnRound();
             });
         }
         mExecutorService.shutdown();
    }

}

//串行程序
public class Person {
    private static void sleep(long time){
        try{
            Thread.sleep(time);
        }catch (Exception e) {
            // TODO: handle exception
        }
    }
    public  void takeATurnRound(){
        sleep(1000*60*10);
    }
    public static void main(String[]arg){
        Person mPerson=new Person();
        mPerson.takeATurnRound();
        mPerson.takeATurnRound();
        mPerson.takeATurnRound();
    }

}

上面程序简单演示了一个人跑了三圈,这种并行程序设计严重影响程序性能,可伸缩性极低,不如串行程序,当并发数增加的时候计算能力反而下降了.

提高可伸缩性

上面例子可以知道可伸缩最大的威胁就是独占方式的资源锁,所以我们可以通过减少竞争来提升可伸缩性,通过如下方式来减少竞争

1. 缩小锁的范围

//错误做法
public class PasswordStore {
private HashMap<String,String>mPasswordMap=new HashMap<>();
public synchronized boolean storePassword(String name,String password){
    boolean tag=false;
    if(password==null||password.length()<6)
        return tag;
    String mPasswordKey=name;
    String passwordEncord=doCrypto(password);
    try{
        //储存密码
        mPasswordMap.put(mPasswordKey, passwordEncord);
        tag=true;
    }catch(Exception e){
        tag=false;
    }
    return tag;
}
//加密
private String doCrypto(String password){
    return password;
}
}

//正确做法
public class PasswordStore {
private HashMap<String,String>mPasswordMap=new HashMap<>();
public boolean storePassword(String name,String password){
    boolean tag=false;
    if(password==null||password.length()<6)
        return tag;
    String mPasswordKey=name;
    String passwordEncord=doCrypto(password);
    try{
        synchronized (this) {
            mPasswordMap.put(mPasswordKey, passwordEncord);
            return true;    
        }

    }catch(Exception e){
        return false;
    }
    return tag;
}
//加密
private String doCrypto(String password){
    return password;
}
}

通过缩小storePassword方法锁的范围,极大的减少了持有锁执行指令数量,根据Amdahl定律,减少串行代码增加并行代码量可以提升可伸缩性.在实际中其实我们可以使用ConcurrentHashMap来代替HashMap达到线程安全,以及代替HashTable提升锁性能,因为ConcurrentHashMap使用了锁分段Segment等技术, 控制粒度都处理的很好.不得不佩服创造ConcurrentHashMap这位大神Doug Lea!

1. 减少锁的粒度(锁分解)

public class LockDecomposed {
private List<String>books=new ArrayList<String>();
private Set<String> mEmployee=new HashSet<>();
public void storeBook(String book){
    /**
     * 错误加锁方式
     * synchronized (this) {
     *  books.add(book);
     *}
     */
    synchronized (books) {
        books.add(book);
    }
}
public void addStaff(String name){
    /**
     *错误加锁方式
     * synchronized (this) {
     *  mEmployee.add(name);
     *}
     */
    synchronized (mEmployee) {
        mEmployee.add(name);
    }
}   
}

以上只是简单例子,可能不符合单一职责原则.如果synchronize(this)锁住的对象为添加员工和储存书本 时候线程会发生竞争, 竞争时候的线程会被挂起, 然后等待, 等待结束被唤醒在加入系统的线程调度队
列中,通过锁分解把没必要开销去除

1. 锁分段

参考ConcurrentHashMap.
通过Segment把竞争性缩小

1. 使用共享锁代替独占锁
   每年春运让人又爱有恨啊,以下模拟下买票系统来说明共享锁和独占锁
   首先进行简单的说明 , 以下用了JDK提供的共享锁 ReentrantReadWriteLock,
   ReentrantReadWriteLock是JDK(concurrent包下的实现类,内部包含ReadLock和 WriteLock)ReadLock和WriteLock 有什么区别呢?WriteLock可以理解为独占锁,ReadLock才是共 享锁的体现, ReentrantReadWriteLock把他们封装在一块,执WriteLock.lock(),TickerServer 内部只有单线程,所有读取线程会被Park挂起,当前线程执行 ReadLock.lock()当前线程会往后看看还有没有跟自己一样以SHAED模式被Park(挂起)起来的线程(存放 AQS里面双向链表),没有往下执行查询逻辑, 有的话会唤醒它(被唤醒的线程做同样的逻辑唤醒它下面的线 程)并行查询票.
   其实啊ReentrantReadWriteLock内部组合着一个很重要的变量Syn, Syn 是 ReentrantReadWriteLock的一个实现AQS的内部类,实际上WriteLock.lock和ReadLock.lock的逻 辑加锁都会交给Syn去完成.Syn会调用父类AQS去完成共享锁和独占锁.AQS可以说是Doug Lea一大杰作, 是 Java JDK的concurrent这个包下的核心类.
   独占锁实现的方式如下

//@author cenxiaozhong
//独占锁方式实现的模拟服务器
public class TicketServer {
private static final List<TicketBean> mTicketBeans = new ArrayList<>();
private static TicketServer mTicketServer = null;
private Random mRandom = null;
/**
 * 默认有一万张票
 */
static {
    for (int i = 0; i < 10000; i++) {
        mTicketBeans.add(new TicketBean(i + 1));
    }
}
private TicketServer() {
    mRandom = new Random();
}
public List<TicketBean> queryTicket() {
    return mTicketBeans;
}
public synchronized int queryTicketNumber() {
    System.out.println(" queryTicketNumber  current size:" + mTicketBeans.size() + "   thread:" + Thread.currentThread().getName());
    try {
        Thread.sleep(10);//做耗时的logic
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return mTicketBeans.size();
}

/**单例模式**/
public static TicketServer getInstance() {
    if (mTicketServer == null) {
        synchronized (TicketServer.class) {
            if (mTicketServer == null) {
                mTicketServer = new TicketServer();
            }
        }
    }
    return mTicketServer;
}
/**加锁模拟买票系统**/
public synchronized TicketBean buyTicket(String name, double price) {

    int position = -1;
    int size = mTicketBeans.size();
    if (size <= 0) {//查询一下有没有票
        return null;
    } else {
        position = mRandom.nextInt(size);//随机一张票
    }
    TicketBean mTicketBean = mTicketBeans.get(position);
    if (price < mTicketBean.getTicketMoney()) {//判断要付的金额
        return null;
    }
    mTicketBeans.remove(position);//系统移除该票, 改票已经卖出来了
    mTicketBean.setTicketBelong(name);//设置一下票的所属者
    mTicketBean.setTicketKey(Thread.currentThread().getName());
    System.out.println(" buy  current size:" + mTicketBeans.size() + "   Thread:" + Thread.currentThread());
    return mTicketBean;
}
}

上面独占锁的方式实现卖票模拟器, synchronized的对象是TicketServer, 所以无论是执行买票逻辑 还是
进行查询剩余的票数的时候内部都只有一个线程在执行,来达到线程安全, 但是这种做法是不提倡,因为这样 做线程的可伸缩性非常死, 提高并发量的时候性能并没有提升.

/**
* 
* @author cenxiaozhong
* 以共享锁模式卖票服务器,也就是说对查询票的数量允许
* 多个线程进入查询, 但是对卖票必须进行锁定,只有一个线程
* 可以进行对票操作
*/
public class TicketServer {
private Random mRandom = null;
//票容器
private static final List<TicketBean> mTicketBeans = new ArrayList<>();
private static TicketServer mTicketServer = null;
// 原子类
private static final AtomicReference<TicketServer> ATOMIC_REFERENCE = new AtomicReference<TicketServer>();
//共享锁  JDK提供, author Doug Lea
private ReentrantReadWriteLock mReentrantReadWriteLock = new ReentrantReadWriteLock();
/**
 * 默认有一万张票
 */
static {
    for (int i = 0; i < 10000; i++) {
        mTicketBeans.add(new TicketBean(i + 1));
    }
}

private TicketServer() {
    mRandom = new Random();
}

// 不加锁危险,
// public List<TicketBean> queryTicket() {
// return mTicketBeans;
// }
// 共享方式查询票数
public int queryTicketNumber() {
    ReentrantReadWriteLock.ReadLock mReadLock = mReentrantReadWriteLock.readLock();// 获取读取lock
    mReadLock.lock();// lock , 读是共享, 也就是 读的时候 其他线程依然可进这段代码进行查询票数
    try {
        try {
            Thread.sleep(10);// 睡一小会
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(" queryTicketNumber  current size:" + mTicketBeans.size() + "   thread:"
                + Thread.currentThread().getName());
        return mTicketBeans.size();
    } finally {
        mReadLock.unlock();// 一定别忘了unLock 否则出现死锁 具体请查看AQS源码

    }

}

//单例模式
public static TicketServer getInstance() {
    while (true) {
        mTicketServer = ATOMIC_REFERENCE.get();
        if (mTicketServer != null)
            return mTicketServer;
        mTicketServer = new TicketServer();
        if (ATOMIC_REFERENCE.compareAndSet(null, mTicketServer))
            return ATOMIC_REFERENCE.get();
    }

}
//买票
public TicketBean buyTicket(String name, double price) {
    ReentrantReadWriteLock.WriteLock mWriteLock = mReentrantReadWriteLock.writeLock();
    int position = -1;
    mWriteLock.lock();
    try {
        int size = mTicketBeans.size();//简单查询一下票的数量
        if (size <= 0) {
            return null;//没有票了
        } else {
            position = mRandom.nextInt(size);//随机一张票
        }
        TicketBean mTicketBean = mTicketBeans.get(position);
        if (price < mTicketBean.getTicketMoney()) {//简单的判断当前票的价格
            return null;
        }
        mTicketBeans.remove(position);//移除票
        mTicketBean.setTicketBelong(name);//设置票的所属者
        mTicketBean.setTicketKey(Thread.currentThread().getName());
        System.out.println(" buy  current size:" + mTicketBeans.size() + "   Thread:" + Thread.currentThread());
        return mTicketBean;
    } finally {
        mWriteLock.unlock();//释放写锁
    }
}

}

可以看出查询和买票用了不同锁,共享锁大大提升程序性能. 能避免独占锁尽量避免独占锁

以下是模拟客户端

//@author cenxiaozhong
public class Clients {
public static void main(String[] args) {
    //线程池
    ExecutorService mExecutorService = Executors.newCachedThreadPool();
    TicketServer mTicketServer = TicketServer.getInstance();
    //线程的计数器
    CountDownLatch mCountDownLatch = new CountDownLatch(1100);
    //记录一下当前时间
    long startTime = System.currentTimeMillis();
    System.out.println("startTime:" + startTime);
    //for循环启动100个线程买票
    for (int i = 0; i < 100; i++) {
        mExecutorService.execute(() -> {
            while (true) {
                sleep(50);//睡一会提高并发量
                TicketBean mTicketBean = mTicketServer.buyTicket(Thread.currentThread().getName(), 800);
                if (mTicketBean != null) {
                    continue;
                } else {
                    break;
                }
            }
            try {//减一
                mCountDownLatch.countDown();
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
    }

        //启动一千个线程查询还有多少票
    for (int i = 0; i < 1000; i++) {
        mExecutorService.execute(() -> {
            sleep(5);//睡一小会
            int member = mTicketServer.queryTicketNumber();//查询票
            try {
                //线程减一
                mCountDownLatch.countDown();
            } catch (Exception e) {
                e.printStackTrace();
            }
        });

    }
    try {
        //主线程等待   知道1100个线程执行完毕后唤醒
        mCountDownLatch.await();
        //关闭线程池
        mExecutorService.shutdown();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    long endTime = System.currentTimeMillis();
    System.out.println("endTime:" + endTime + "      extra:" + (endTime - startTime));
}
public static void sleep(long time) {
    try {
        Thread.sleep(time);
    } catch (Exception e) {
        e.printStackTrace();
    }
}
}

执行结果

执行环境Mac os 10.12.2,四核 i7 16G运存

endTime:1486803316222      extra:6170//使用了共享锁
endTime:1486805339097      extra:17140//使用了独占锁

可以看出来共享锁比独占锁效率高出了接近三倍, 其实不止, 会随之查询并发数增大而不同,很大一
个原因是因为独占锁进行查询的时候会排斥所有线程.

1. 在高并发情况不使用对象池(享元模式).享元模式对资源重新利用,用空间换时间, 提高了性能.但是在并发情况反而带来开销.

* Return a new Message instance from the global pool. Allows us to
 * avoid allocating new objects in many cases.
 */
public static Message obtain() {
    synchronized (sPoolSync) {
        if (sPool != null) {
            Message m = sPool;
            sPool = m.next;
            m.next = null;
            m.flags = 0; // clear in-use flag
            sPoolSize--;
            return m;
        }
    }
    return new Message();
}

以上可以看出从对象池获取对象是必须要加锁,不加锁会出现不同线程拿到相同对象Message,这是不允许的,加锁意味着在多线程访问中会出现阻塞, 阻塞,唤醒等开销足以new 出数百个Message对象了.所以在并发频率很高时候不使用对象池.

1. 等等.

Demo : Github