从汇编去分析线程安全

首先要知道什么是线程安全？

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

典型线程不安全的列子：

 1 import java.util.*;

class Worker implements Runnable {
    private UnsafeCount unsafeCount;

    public Worker(UnsafeCount unsafeCount) {
        this.unsafeCount = unsafeCount;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (int i = 0; i < 1000; i++)
            unsafeCount.increase();
    }

}

public class UnsafeCount {
    private int count = 0;

    public void increase() {
        count++;
    }

    public int getCount() {
        return count;
    }

    public static void main(String[] args) throws InterruptedException {
        UnsafeCount uc = new UnsafeCount();
        
        //这里用了list简陋的方式控制线程的结束，更好的实现是用闭锁CountDownLatch或者栅栏CyclicBarrier
        List<Thread> list = new ArrayList<Thread>();//
        
        for (int i = 0; i < 10; i++) {
            Thread worker = new Thread(new Worker(uc));
            worker.start();
            list.add(worker);
        }

        //阻塞直到线程结束
        for (Thread t : list) {
            t.join();
        }

        System.out.println("total is: " + uc.getCount());

    }
}

运行结果（每次结果都不一样）：
total is: 7628

我们来仔细分析一下这个结果，开启10个线程运行，每个线程都对count进行了1000次自增操作，期望的结果应该是1000*10=10000。很明显运行结果与期望结果不一致。结论是这个类是线程不安全的。为什么会出现这种情况了？

原因是count++这个操作不是原子性，其实这个自增操作是个复合操作：读-改-写。 如果我们了解汇编语言的话，对应自增操作的汇编程序可能是：

movl count, %eax　　#将count的值读入eax的寄存器中,
inc %eax　　#寄存器eax里的值加1，即改写count值
movl %eax, %ebx　　#这里ebx寄存器存存放着count的内存地址，这里是值将改写的count值写入到内存中

那么这样就存在一个问题，假如就存在2个线程A和B操作变量count，初始化时刻count为0. 在线程A未写入改写值之前，比如在A线程执行步骤2的时刻， 线程B开始执行，如下所示：

线程A读入count值为0 （步骤1）　　-》　　改写count值为1（步骤2）　　-》　将改写后的count值写入内存中（步骤3）　

 　　　　　　　　　　　　　　　　　　　　线程A读入count值为0 （步骤1）　　-》　　改写count值为1（步骤2）　　-》　将改写后的count值写入内存中（步骤3）

因为线程A还没有更新改写count的值到内存，这时线程B读入count的值仍旧是0，导致最后2个线程结束后count的值为1。由此可见做了2次自增的操作，期望结果是2，但实际结果可能是1.这也是线程不安全的情况下，自增的操作的实际结果往往比期望结果小的原因。

下篇准备将讲什么情况是线程不安全的。