线程安全

本文主要内容

• 线程安全概念
• 互斥同步
• 非阻塞同步
• 无同步方案

线程安全概念

当多个线程访问一个对象时，如果不用考虑这些线程在运行时环境下的调试和交替执行，也不需要进行额外的同步，或者在调用方进行任何其它的协调操作，调用这个对象的行为都可以获得正确的结果，那这个对象就是线程安全的。

同步是指在多个线程并发访问共享数据时，保证共享数据在同一时刻只被一条线程使用

Java中实现线程安全方法有三种（根据原理分类）：互斥同步、非阻塞同步、无同步方案。下面将分别介绍三种方案

互斥同步

互斥是实现同步的一种手段，属于一种悲观的并发策略，总是认为只要不去做正确的同步措施，那就会出问题，无论共享数据是否真的会出现竞争，它都要加锁。

Java中最基础的互斥手段就是synchronized关键字，synchronized关键字经过编译后，会在同步块的前后分别弄成monitorenter他monitorexit这两个字节码指令，这两个字节码指令都需要一个reference类型的参数来指明要锁定和解锁的对象，即对象锁。

在执行monitorenter指令时，首先要尝试获取对象锁，如果这个对象没被锁定或者当前线程已经拥有对象锁，则锁的计数器加1，相应地，在执行monitorexit指令时，锁计数器减1，当计数器为0时，锁就释放了。如果获取对象锁失败了，那当前线程就要阻塞等待，直到对象锁被另外一个线程释放为止

记住：synchronized是可重入的，即已经获得对象锁时可再次获取对象锁

使用synchronized实现生产者、消费者模型：

public void put(T t) throws InterruptedException{
    synchronized (lock) {
        if (count == mMaxSize) {
            System.out.println("tname = " + Thread.currentThread().getName() + "  已满， 待会再生产");
            lock.wait();
        }
        items[tail] = t;
        if (++tail == mMaxSize) {
            tail = 0;
        }
        count++;
        System.out.println("tname = " + Thread.currentThread().getName() + " 生产1个， 当前个数为： " + count);
    }
}

public T take() throws InterruptedException{
    synchronized (lock) {
        if (count == 0) {
            System.out.println("tname = " + Thread.currentThread().getName() + "  空了，等会再取");
            lock.wait();
        }
        T r = items[head];
        items[head] = null;
        if (++head == mMaxSize) {
            head = 0;
        }
        count--;
        System.out.println("tname = " + Thread.currentThread().getName() + " 消费1个，  当前个数为： " + count);
        return r;
    }
}

除了synchronized关键字外，我们还可以使用ReentrantLock来实现同步。ReentrantLock一样具有线程重入特性，但写法和synchronized有差异，一个是API层面的互斥锁，一个表现为原生语法层面的互斥锁。

ReentrantLock的lock和unlock方法一定要配合try/finally语句块来完成，而且lock和unlock要成对出现，有几个lock操作就要执行几次unlock

ReentrantLock相比synchronized来说更加强大：

• 可实现公平锁：ReentrantLock构造方法为true则可实现公平锁，相对而言等待最长的线程将获得锁而不是随机获取了，但公平锁效率低下
• 等待可中断：正在等待的线程可以选择放弃等待
• 锁可以绑定多个条件：即ReentrantLock可以同步绑定多个Condition对象，Condition的await和signal方法与wait和notify方法相对应。一般来说，如果要和多于一个的条件关联的时候，就不得不额外地添加一个锁，而ReentrantLock不需要这样做，只要多次调用newCondition()方法即可。

使用ReentrantLock实现生产者、消费者模型：

public void put(T t) throws InterruptedException{
    lock.lock();
    try {
        if (count == mMaxSize) {
            System.out.println("tname = " + Thread.currentThread().getName() + "  已满， 待会再生产");
            full.await();
        }
        items[tail] = t;
        if (++tail == mMaxSize) {
            tail = 0;
        }
        count++;
        System.out.println("tname = " + Thread.currentThread().getName() + " 生产1个， 当前个数为： " + count);
        empty.signal();
    } finally {
        lock.unlock();
    }
}

public T take() throws InterruptedException{
    lock.lock();
    try{
        if (count == 0) {
            System.out.println("tname = " + Thread.currentThread().getName() + "  空了，等会再取");
            empty.await();
        }
        T r = items[head];
        items[head] = null;
        if (++head == mMaxSize) {
            head = 0;
        }
        count--;
        System.out.println("tname = " + Thread.currentThread().getName() + " 消费1个，  当前个数为： " + count);
        full.signal();
        return r;
    }finally{
        lock.unlock();
    }
}

非阻塞同步

互斥同步是悲观策略，那么非阻塞同步就是乐观策略，基于冲突检测的乐观并发策略。

通俗地说就是先进行操作，如果没有其它线程争用共享数据，那操作就成功了，如果共享数据有争用，产生了冲突，那就再进行其它的补偿措施（最常用的补偿措施就是不断地重试，直到试成功为止），这种乐观的并发策略不需要把线程挂起，所以称为非阻塞同步

乐观并发策略依赖“硬件指令发展”，因为我们需要操作和冲突检测这两个步骤具备原子性，如果不考虑互斥来实现，那只能使用硬件来完成了，硬件保证一个从主义上看起来需要多次操作的行为只通过一条处理器指令就能完成，这类指令常用的有：

• 测试并设备（Test-and-Set）
• 获取并增加（Fetch-and-Increment）
• 交换（Swap）
• 比较并交换（Compare-and-Swap，下方称CAS）

CAS需要三个操作数，分别是内存位置（用V表示），旧的预期值（用A表示）和新值（用B表示）。CAS执行时，当且仅当V符合旧预期值A时，处理器用新值B更新V的值，否则它就不执行。

JDK1.5之后，java程序才可以使用CAS操作，该操作由Unsafe类里边的compareAndSwapInt等几个方法包装提供。

public static AtomicInteger atoRace = new AtomicInteger(0);
public static void increase2(){
    atoRace.incrementAndGet();
}
for (int i = 0; i < threads.length; i++) {
        threads[i] = new Thread(){
            public void run() {
                for (int j = 0; j < 10000; j++) {
                    increase();
                    increase2();
                }
            }
        };
        threads[i].start();
    }

这段代码执行结果，atoRace值将为200000，正确结果。查看AtomicInteger的源码：

public final int incrementAndGet() {
    for (;;) {
        int current = get();
        int next = current + 1;
        if (compareAndSet(current, next))
            return next;
    }
}

compareAndSet方法调用了unsafe类的compareAndSwapInt方法，CAS操作，硬件保证了操作的原子特性，所以能够得到正确的值。

如果某些场景里能够使用乐观锁解决问题的，尽量使用乐观锁解决问题，因为它的效率比悲观锁要高很多。悲观锁需要执行加锁、用户态核心态转换、维护锁计数器和检查是否有被阻塞的线程需要被唤醒等，较耗时。

无同步方案

线程本地存储就是一种无同步方案，具体类则是ThreadLocal类，它以线程为key，值为value，这样就能保证为不同线程存储不同的值了，具体不再过多描述，具体示例可以参数Android的Handler类。