【Java并发学习】之原子类

前言

在前面的学习中，在处理一些数据的增加，减少，比如Integer类型的数据的增加或者减少的时候，为了使数据保持一致，使用了synchronized 或者Lock对方法或者代码块进行锁操作，进入临界区的时候，进行加锁，离开临界区的时候，进行解锁。除了这种方式外，在JDK1.5中，提供了另外一种机制，原子类操作对象，接下来我们来具体学习这几个有用的工具

Atomic*家族介绍及操作

上面的内容来自JUC包(java.utils.concurrent.atomic)，从上图中可以看到，Atomic家族有非常多的工具类，图中红框部分看上去眼熟，它们是常用的基本类型的包装类的原子工具

在前面我们提到了基本数据类型(包括其包装类)的部分操作并不是原子操作，比如

    int a;    a++; // 注意该不是原子操作

换句话说，在多线程环境下，这些操作存在线程安全性问题，在没有原子类之前，为了实现线程安全性操作，我们会对这些操作进行加锁处理，简单的临界区进行加锁处理固然不复杂，但是当临界区数量比较多的时候，就比较容易造成死锁等一系列的问题，除此之外，频繁的加锁、解锁处理也会带来性能的问题，在JDK1.5的时候，JDK设计者采用新的处理机制CAS，关于该机制，在后面中将具体来学习，通过该机制，可以实现更轻量级的锁操作，并且在Atomic家族中提供了对应的封装，也就是我们上面看到的Atomic家族

接下来我们来看下如何使用Atomic家族中的AtomicInteger

public class AtomicTest {    public static void main(String[] args) {        // 初始化其值为1        AtomicInteger data = new AtomicInteger(1);        AtomicTask[] tasks = new AtomicTask[10];        for (int i = 0; i < 10; i++) {            tasks[i] = new AtomicTask(data);        }        ExecutorService service = Executors.newCachedThreadPool();        for (int i = 0; i < 10; i++){            service.submit(tasks[i]);        }        service.shutdown();        while (!service.isTerminated()){} // 等待任务完成        System.out.printf("Result is : %d\n", data.get());    }}// 模拟加法任务class AtomicTask implements Runnable {    private AtomicInteger data;    public AtomicTask(AtomicInteger data) {        this.data = data;    }    @Override    public void run() {        for (int i = 0; i < 10000; i++){            // 获取并且增加1            data.addAndGet(1);            Thread.yield();        }    }}

上面的代码简单地演示了AtomicInteger的使用，其他的类，如AtomicLong的使用类似于AtomicInteger，这个不进行过多的阐述

性能测试

这里做一个简单的性能测试，测试使用synchronized以及AtomicInteger 执行相同数量的操作之后的时间

class AtomicTask implements Runnable {    // 同上，这里省略}class SynTask implements Runnable {    private Integer[] data;    public SynTask(Integer[] data) {        this.data = data;    }    // 这里需要注意，由于是对同一个data进行操作，而创建了多个任务，所以需要锁住SynTask.class对象    private void addOne(){        synchronized (SynTask.class) {            data[0]++;        }    }    @Override    public void run() {        for (int i = 0; i < 10000; i++){            addOne();            Thread.yield();        }    }}

测试代码

public class AtomicTest {    public static void main(String[] args) {       //  AtomicInteger data = new AtomicInteger(1);        // AtomicTask[] tasks = new AtomicTask[1000];        SynTask[] tasks = new SynTask[1000];         Integer[] data = new Integer[1];         data[0] = 1;        for (int i = 0; i < 1000; i++) {           // tasks[i] = new AtomicTask(data);            tasks[i] = new SynTask(data);        }        ExecutorService service = Executors.newCachedThreadPool();        long startTime = System.currentTimeMillis();        for (int i = 0; i < 1000; i++){            service.submit(tasks[i]);        }        service.shutdown();        while (!service.isTerminated()){}        long endTime = System.currentTimeMillis();        //System.out.printf("Result is : %d\n", data.get());        System.out.printf("Result is : %d\n", data[0]);        System.out.printf("Cost Time : %d ms\n", (endTime - startTime));    }}

# AtomicTask结果Result is : 10000001Cost Time : 9652 ms# SynTask结果Result is : 10000001Cost Time : 11220 ms

从上面的结果可以看到，这两者之间的差距在数据量比较大的时候还是有明显的差距的

总结

本小节我们学习了新的并发工具，Atomic家族，并且简单地学习了AtomicInteger的操作，然后对两种不同的操作进行性能测试，从测试的结果可以看出两者的一些差距，关于Atomic家族的详细剖析以及对应的实现机制，在后面的学习中将陆续进行介绍(其实是现在还未能完全弄懂，囧…)