---

title: 【Java并发学习】之原子类
date: 2017-11-28 22:02:15
tags: [Java, 多线程]
categories: Java

---

【Java并发学习】之原子类

前言

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

Atomic*家族介绍及操作

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 : 10000001
Cost Time : 9652 ms

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

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

总结

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