title: 【Java并发学习】之原子类
date: 2017-11-28 22:02:15
tags: [Java, 多线程]
categories: Java
【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 : 10000001
Cost Time : 9652 ms
# SynTask结果
Result is : 10000001
Cost Time : 11220 ms
从上面的结果可以看到，这两者之间的差距在数据量比较大的时候还是有明显的差距的
总结
本小节我们学习了新的并发工具，Atomic家族，并且简单地学习了AtomicInteger的操作，然后对两种不同的操作进行性能测试，从测试的结果可以看出两者的一些差距，关于Atomic家族的详细剖析以及对应的实现机制，在后面的学习中将陆续进行介绍(其实是现在还未能完全弄懂，囧...)
