java多线程实战学习2-原子性

原子性

原子性，这个应该是广义的名词，在数据库中用的更常见，指的是一个操作的执行是完全执行完的，不能被打断，要么全部执行，要不完全不执行，不能执行一半。
这个也是java多线程的基础，例如i++这个操作，本身不是原子性的，它包含三个操作

1. 寄存器读取i的内存中的值
2. 寄存器中执行i+1操作
3. 寄存器将新值赋到i变量的内存中

另外，java基本类型中long和double的写也不是原子性的，分两次写入。

例子

下面的代码

public class UnAtomicTest {
    private volatile int number = 0;

    public void addNumber() {
        number++;
    }

    public int getNumber() {
        return number;
    }

    public static void main(String[] strings) {
        UnAtomicTest unAtomicTest = new UnAtomicTest();
        int threadNumber = 5;
        long start = System.currentTimeMillis();
        CountDownLatch countDownLatch = new CountDownLatch(threadNumber);
        for (int i = 0; i < threadNumber; i++) {
            Thread thread = new SubThread(countDownLatch, unAtomicTest);
            thread.start();
        }

        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long cost = System.currentTimeMillis() - start;
        System.out.println(unAtomicTest.getNumber() + " cost:" + cost);
    }

    private static class SubThread extends Thread {
        private CountDownLatch countDownLatch;
        private UnAtomicTest unAtomicTest;

        public SubThread(CountDownLatch countDownLatch, UnAtomicTest unAtomicTest) {
            this.countDownLatch = countDownLatch;
            this.unAtomicTest = unAtomicTest;
        }

        @Override
        public void run() {
            for (int i = 0; i < 1000000; i++) {
                unAtomicTest.addNumber();
            }
            this.countDownLatch.countDown();
        }

    }
}

运行后发现，每次执行的结果不一样，不会是5000000，都是个随机值。

其实通过这个例子，我们可以加深volatile的理解，它只代码number在各个线程之间是可见的，但是并不能保证原子性。

addNumber里面的i++不是原子性操作, 所以会存在下面的情况

两个线程同时读取i的值，这样机会导致结果和预期不一致。

synchronized

这个关键字synchronized是给方法或者代码段加锁，保证这个方法或者某个代码段只会有一个线程能访问，在这个线程访问的时候，其他线程只能等待。
改造如下

public class AtomicTest {
    private volatile int number = 0;

    public synchronized void addNumber() {
        number++;
    }

    public int getNumber() {
        return number;
    }

    public static void main(String[] strings) {
        AtomicTest unAtomicTest = new AtomicTest();
        int threadNumber = 5;
        long start = System.currentTimeMillis();
        CountDownLatch countDownLatch = new CountDownLatch(threadNumber);
        for (int i = 0; i < threadNumber; i++) {
            Thread thread = new SubThread(countDownLatch, unAtomicTest);
            thread.start();
        }

        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long cost = System.currentTimeMillis() - start;
        System.out.println(unAtomicTest.getNumber() + " cost:" + cost);
    }

    private static class SubThread extends Thread {
        private CountDownLatch countDownLatch;
        private AtomicTest unAtomicTest;

        public SubThread(CountDownLatch countDownLatch, AtomicTest unAtomicTest) {
            this.countDownLatch = countDownLatch;
            this.unAtomicTest = unAtomicTest;
        }

        @Override
        public void run() {
            for (int i = 0; i < 1000000; i++) {
                unAtomicTest.addNumber();
            }
            this.countDownLatch.countDown();
        }

    }
}

修改之后，每次的结果都是5000000。
同时我们比较两次的耗时，在本人电脑上面，UnAtomicTest耗时78ms，AtomicTest耗时151ms。synchronized会大大增加耗时。

有没有更好的方法呢，有AtomicInteger

AtomicInteger

public class AtomicIntegerTest {
    private AtomicInteger number = new AtomicInteger();

    public void addNumber() {
        number.incrementAndGet();
    }

    public int getNumber() {
        return number.get();
    }

    public static void main(String[] strings) {
        AtomicIntegerTest unAtomicTest = new AtomicIntegerTest();
        int threadNumber = 5;
        long start = System.currentTimeMillis();
        CountDownLatch countDownLatch = new CountDownLatch(threadNumber);
        for (int i = 0; i < threadNumber; i++) {
            Thread thread = new SubThread(countDownLatch, unAtomicTest);
            thread.start();
        }

        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long cost = System.currentTimeMillis() - start;
        System.out.println(unAtomicTest.getNumber() + " cost:" + cost);
    }

    private static class SubThread extends Thread {
        private CountDownLatch countDownLatch;
        private AtomicIntegerTest unAtomicTest;

        public SubThread(CountDownLatch countDownLatch, AtomicIntegerTest unAtomicTest) {
            this.countDownLatch = countDownLatch;
            this.unAtomicTest = unAtomicTest;
        }

        @Override
        public void run() {
            for (int i = 0; i < 1000000; i++) {
                unAtomicTest.addNumber();
            }
            this.countDownLatch.countDown();
        }

    }
}

执行后结果正确，耗时大大减少，笔者电脑耗时85ms。

AtomicInteger

AtomicInteger的源码我们可以看到引入了一个unsafe类，它其实越过了虚拟机，从底层实现了原子性。但是有意思的是一开始的时候AtomicInteger开始就用的synchronized,随着java版本的不断进化才开始使用unsafe。

AtomicInteger可以参考AtomicInteger讲解

unsafe可以参考 Java魔法类：Unsafe应用解析

AtomicInteger的i++操作采用了CAS方法，具体参考深入浅出 Java Concurrency (5): 原子操作 part 4