【Java并发学习】之原子类

时间:2022-05-01 18:01:28

【Java并发学习】之原子类

前言

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

Atomic*家族介绍及操作

【Java并发学习】之原子类

上面的内容来自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家族的详细剖析以及对应的实现机制,在后面的学习中将陆续进行介绍(其实是现在还未能完全弄懂,囧…)