【并发】保证共享变量在多线程并发时的线程安全

Code：

public class AdderTest {

    static int i;
    static CountDownLatch latch = new CountDownLatch(2);

    public static void main(String[] args) throws InterruptedException {

        Runnable task = new Runnable() {
            @Override
            public void run() {
                int x = 0;
                while (x++ < 100000){
                        i++;
                }
                latch.countDown();
            }
        };

        Thread adder1 = new Thread(task, "Adder-1");
        Thread adder2 = new Thread(task,"Adder-2");

        //开启两个加法器线程
        adder1.start();
        adder2.start();

        //主线程阻塞，等待两个加法器线程完成操作
        latch.await();

        System.out.println(i);
    }
}

? ? ? ? 两个Adder线程执行同样的操作：累加共享变量i，执行这个操作十万次；使用CountDownLatch是为了让主线程等待两个Adder线程执行完累加操作，最后打印共享变量i，看共享变量i的最终值是否是我们预期的二十万。

? ? ? ? 共享变量i的最终值：

? ? ? ? 每次执行的结果都不相同，但这些结果有一个共同点：都小于二十万。为什么会出现这种情况呢？因为在字节码中，i++可不仅仅是一步操作。

0: getstatic #2     // 获取静态变量i的值
3: iconst_1         // 将常量1推送到栈顶
4: iadd             // 将栈顶两个int型数值相加
5: putstatic #2    // 将相加后的值存储到静态变量i
8: return           // 返回

? ? ? ? 可以看到，一个简单的i++代码在字节码中包含四步，这四步即包含读又包含写，而多线程场景下，对共享变量进行读、写操作无疑会产生线程安全问题。因为线程对共享变量执行读、写操作时无法保证这两个操作的原子性。

? ? ? ? 依照上图，假设静态变量i的值一开始是1，线程Adder-1先获取了静态变量i的值，执行+1操作，准备赋值给静态变量i时，线程Adder-1的CPU时间片用完了，线程被挂起；随后线程Adder-2也来执行相同的操作，由于它的CPU时间片充足，它能完整的执行所有操作。

? ? ? ? 假设线程Adder-2在线程Adder-1挂起的这段时间，执行了三次完整操作，那么静态变量i的值就是4。此时线程Adder-1又获得了CPU的时间片，能够继续执行赋值操作，将静态变量i的值修改成2，这就相当于将线程Adder-2之前三次操作的结果给覆盖掉了，这也是为什么最终结果总是小于预期值的原因。

解决方案：

????????（1）悲观锁

? ? ? ? synchronized：

public class AdderTest {

    static int i;
    static CountDownLatch latch = new CountDownLatch(2);

    public static void main(String[] args) throws InterruptedException {

        Object lock = new Object();
        Runnable task = new Runnable() {
            @Override
            public void run() {
                int x = 0;
                synchronized (lock){
                    while (x++ < 100000) {
                        i++;
                    }
                }
                latch.countDown();
            }
        };

        Thread adder1 = new Thread(task, "Adder-1");
        Thread adder2 = new Thread(task,"Adder-2");

        //开启两个加法器线程
        adder1.start();
        adder2.start();

        //主线程阻塞，等待两个加法器线程完成操作
        latch.await();

        System.out.println(i);
    }
}

? ? ? ? 为了减少锁带来的性能影响，我们希望锁粒度尽可能小，一般只会对存在共享变量读、写的临界区代码块上锁（这里临界区代码块是i++），但这里为了减少多次获得锁、释放锁带来的性能影响，我们应该把锁放在while循环外。

? ? ? ? ReentrantLock:

public class AdderTest {

    static int i;
    static CountDownLatch latch = new CountDownLatch(2);

    public static void main(String[] args) throws InterruptedException {
        ReentrantLock lock = new ReentrantLock();
        Runnable task = new Runnable() {
            @Override
            public void run() {
                int x = 0;
                try {
                    lock.lock();
                    while (x++ < 100000){
                        i++;
                    }
                }finally {
                    lock.unlock();
                }
                latch.countDown();
            }
        };

        Thread adder1 = new Thread(task, "Adder-1");
        Thread adder2 = new Thread(task,"Adder-2");

        //开启两个加法器线程
        adder1.start();
        adder2.start();

        //主线程阻塞，等待两个加法器线程完成操作
        latch.await();

        System.out.println(i);
    }
}

? ? ? ? 使用ReentrantLock实现线程互斥时，一般搭配try、finally一块使用，避免死锁现象产生。对finally机制感兴趣的读者可以看我的另一篇博客：【异常】浅析异常体系及为什么一定会执行finally块-CSDN博客

? ? ? ? 测试：

? ? ? ? （2）乐观锁

? ? ? ? AtomicInteger原子类：

public class AdderTest {

    static AtomicInteger i = new AtomicInteger(0);
    static CountDownLatch latch = new CountDownLatch(2);

    public static void main(String[] args) throws InterruptedException {

        Runnable task = new Runnable() {
            @Override
            public void run() {
                int x = 0;
                while (x++ < 100000) {
                    i.getAndIncrement();
                }
                latch.countDown();
            }
        };

        Thread adder1 = new Thread(task, "Adder-1");
        Thread adder2 = new Thread(task,"Adder-2");

        //开启两个加法器线程
        adder1.start();
        adder2.start();

        //主线程阻塞，等待两个加法器线程完成操作
        latch.await();

        System.out.println(i);
    }
}

? ? ? ? 将静态变量i的实现改为AtomicInteger原子类。多线程操作AtomicaInteger对象时，线程安全由AtomicaInteger内部的Unsafe类基于CAS（乐观锁思想的一种体现）来保证。

? ? ? ? getAndIncrement()方法实现：

public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }


public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;
        do {
            var5 = this.getIntVolatile(var1, var2);
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

        return var5;
    }

? ? ? ? 测试：