java并发学习--第四章 JDK提供的线程原子性操作工具类

　　 在了解JDK提供的线程原子性操作工具类之前，我们应该先知道什么是原子性：在多线程并发的条件下，对于变量的操作是线程安全的，不会受到其他线程的干扰。接下来我们就学习JDK中线程的原子性操作。

一、CAS原理

　　说道原子性，不得不提的就是CAS原理：

　　使用锁时，线程获取锁是一种悲观锁策略，即假设每一次执行临界区代码都会产生冲突，所以当前线程获取到锁的时候同时也会阻塞其他线程获取该锁。而CAS操作（又称为无锁操作）是一种乐观锁策略，它假设所有线程访问共享资源的时候不会出现冲突，既然不会出现冲突自然而然就不会阻塞其他线程的操作。因此，线程就不会出现阻塞停顿的状态。那么，如果出现冲突了怎么办？无锁操作是使用CAS(compare and swap)又叫做比较交换来鉴别线程是否出现冲突，出现冲突就重试当前操作直到没有冲突为止。

　　CAS既然和锁有关，那么它和Synchronized有什么区别呢：

　　元老级的Synchronized(未优化前)最主要的问题是：在存在线程竞争的情况下会出现线程阻塞和唤醒锁带来的性能问题，因为这是一种互斥同步（阻塞同步）。而CAS并不是武断的间线程挂起，当CAS操作失败后会进行一定的尝试，而非进行耗时的挂起唤醒的操作，因此也叫做非阻塞同步。这是两者主要的区别。

二、原子更新基本类型

　　在我们实际开发中，线程原子性问题是比较常见的地方，最简单的例子：i ++；i ++是我们开发中一定会用到的一段代码，但是你知道吗，i ++在多线程环境中是不安全的，我们接下来通过一个例子来说明为什么i ++不安全：

　　

public class Demo2 implements Runnable {

    //给线程方法传递一个参数
    static int count=0;

    /**
     *线程任务，将count的值遍历到10000再输出
     */
    public void run() {
        System.out.println("当前线程获取count的值为:"+count);
        for (int i = 0; i < 10000; i++) {
            count++;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //创建多线程环境，这里创建了10个线程
        Thread[] thread = new Thread[10];
        //未创建的多线程中添加线程任务
        for (int i = 0; i < 10; i++) {
            thread[i] = new Thread(new Demo2());
        }
        //启动每个线程任务
        for (int i = 0; i < 10; i++) {
            thread[i].start();
        }
        //join方法的作用是阻塞主线程，防止还没有计算完成，就开始输出count的值了
        for (int i = 0; i < 10; i++) {
            thread[i].join();
        }
        System.out.println("count计算的结果是:"+count);
    }
}

　　运行的结果是：

　　

　　这里的 count++就是我们说的i ++；可以很明确的看到，count的值除了重复获取外， 执行count++操作时，也是有问题的，这个问题的原因是：count在执行++操作时，因为是多线程环境，假设count的值在第一个线程获取为0了但是还没有完成++操作，就有第二个线程抢到了CPU资源，此时count的值还是0，所以就出现了这个数据重复获取，导致count++操作不准确，因此count++是线程不安全的。

　　面对这样的问题，JDK为我们提供了原子基本类型来解决，一个有三个：

　　　　AtomicBoolean：原子更新布尔类型

　　　  AtomicInteger：原子更新整型

　　　  AtomicLong：原子更新长整型

　　这个三个类中的方法都一致，我们主要使用的是：

　　get()：直接返回值

　　getAndIncrement()：以原子方式将当前值加1，相当于线程安全的i++操作

　　incrementAndGet()：以原子方式将当前值加1，相当于线程安全的++i操作

　　其他的方法可以参考AtomicInteger的API文档，因此我们改造上面的场景：

　　

public class Demo2 implements Runnable {

    //给线程方法传递一个参数
    static AtomicInteger count=new AtomicInteger(0);

    /**
     *线程任务，将count的值遍历到10000再输出
     */
    public void run() {
        System.out.println("当前线程获取count的值为:"+count);
        for (int i = 0; i < 10000; i++) {
            count.incrementAndGet();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //创建多线程环境，这里创建了10个线程
        Thread[] thread = new Thread[10];
        //未创建的多线程中添加线程任务
        for (int i = 0; i < 10; i++) {
            thread[i] = new Thread(new Demo2());
        }
        //启动每个线程任务
        for (int i = 0; i < 10; i++) {
            thread[i].start();
        }
        //join方法的作用是阻塞主线程，防止还没有计算完成，就开始输出count的值了
        for (int i = 0; i < 10; i++) {
            thread[i].join();
        }
        System.out.println("count计算的结果是:"+count);
    }
}

运行结果：

可以看到计算的结果是准确的，证明我们的count ++操作是线程安全的

三、原子更新数组类型

　　atomic包中更新数组类型的方式与更新基本类型类似，一共提供了三种方式：

　   AtomicIntegerArray：原子更新整型数组中的元素；

　   AtomicLongArray：原子更新长整型数组中的元素；

　   AtomicReferenceArray：原子更新引用类型数组中的元素

　   三个类的用法都很相似，我们以AtomicIntegerArray类来作为介绍，一共常用的有3个方法：

　　addAndGet(int i, int delta)：以原子更新的方式将数组中索引为i的元素与输入值相加；

　　getAndIncrement(int i)：以原子更新的方式将数组中索引为i的元素自增加1；

　　compareAndSet(int i, int expect, int update)：将数组中索引为i的位置的元素进行更新（注意这个是非原子性操作）

　　我们就用这个几个方法写一个实例：

　　

public class Demo2 implements  Runnable{

    //给线程方法传递一个参数
    static int[] arr = new int[]{0, 0};

    //将创建的数组传递给AtomicIntegerArray，进行原子性操作
    static AtomicIntegerArray count=new AtomicIntegerArray(arr);

    /**
     *线程任务，将count第一个元素的值赋值让其等于i的值，将第二个元素的值自增
     */
    public void run() {
        for (int i = 0; i < 10000; i++) {
            //以原子更新的方式将数组中索引为i的元素与输入值相加
            count.getAndSet(0, i);
            //以原子更新的方式将数组中索引为i的元素自增加1
            count.getAndIncrement(1);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //创建多线程环境，这里创建了10个线程
        Thread[] thread = new Thread[10];
        //未创建的多线程中添加线程任务
        for (int i = 0; i < 10; i++) {
            thread[i] = new Thread(new Demo2());
        }
        //启动每个线程任务
        for (int i = 0; i < 10; i++) {
            thread[i].start();
        }
        //join方法的作用是阻塞主线程，防止还没有计算完成，就开始输出count的值了
        for (int i = 0; i < 10; i++) {
            thread[i].join();
        }
        System.out.println("计算完成后count数组第一个元素的值为:"+count.get(0));
        System.out.println("计算完成后count数组第二个元素的值为:"+count.get(1));
    }

}

运行的结果：

可以看到，我们在线程任务中进行的自增和赋值操作都是原子性的

四、原子更新类　

　　一共有三种方式

　　AtomicReference：原子更新引用类型

　　AtomicReferenceFieldUpdater：原子更新引用类型里的字段

　　AtomicMarkableReference：原子更新带有标记位的引用类型

　　主要使用的是get和set方法，我们来看一个实例：

public class Demo2 implements  Runnable{

    //创建一个原子更新引用，引用一个Bean对象
    static AtomicReference<Bean> count=new AtomicReference();

    /**
     *线程任务，对bean对象的字段赋值
     */
    public void run() {
        for (int i = 0; i < 10000; i++) {
            //以原子更新的方式将数组中索引为i的元素与输入值相加
            Bean bean=new Bean();
            bean.setName("一共有"+i+"次执行");
            bean.setNum(i);
            count.set(bean);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //创建多线程环境，这里创建了10个线程
        Thread[] thread = new Thread[10];
        //未创建的多线程中添加线程任务
        for (int i = 0; i < 10; i++) {
            thread[i] = new Thread(new Demo2());
        }
        //启动每个线程任务
        for (int i = 0; i < 10; i++) {
            thread[i].start();
        }
        //join方法的作用是阻塞主线程，防止还没有计算完成，就开始输出count的值了
        for (int i = 0; i < 10; i++) {
            thread[i].join();
        }
        System.out.println(count.get().getName());
        System.out.println("赋值的结果是"+count.get().num);
    }

}

其中bean对象的代码是：

　　

public class Bean {

    String name;

    int num;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

}

运行的结果

五、原子更新字段

　　AtomicReference：原子更新引用类型；

　　AtomicReferenceFieldUpdater：原子更新引用类型里的字段；

　　AtomicMarkableReference：原子更新带有标记位的引用类型；

public class Demo2 implements  Runnable{

    static Bean bean=new Bean();
    //创建一个原子更新字段对象，更新bean中的num属性
    static AtomicIntegerFieldUpdater<Bean> count=AtomicIntegerFieldUpdater.newUpdater(Bean.class,"num");

    /**
     *线程任务，对bean对象的字段赋值
     */
    public void run() {
        for (int i = 0; i < 10000; i++) {
            //以原子更新的方式将数组中索引为i的元素与输入值相加

            bean.setNum(i);
            count.getAndIncrement(bean);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //创建多线程环境，这里创建了10个线程
        Thread[] thread = new Thread[10];
        //未创建的多线程中添加线程任务
        for (int i = 0; i < 10; i++) {
            thread[i] = new Thread(new Demo2());
        }
        //启动每个线程任务
        for (int i = 0; i < 10; i++) {
            thread[i].start();
        }
        //join方法的作用是阻塞主线程，防止还没有计算完成，就开始输出count的值了
        for (int i = 0; i < 10; i++) {
            thread[i].join();
        }
        System.out.println("赋值的结果是"+count.get(bean));
    }

}