Java多线程_Atomic
1.什么是Atomic？
Atomic，中文意思是“原子的”，在java多线程中，有这样的一个包：
java.util.concurrent.atomic——线程安全的原子操作包
这是JDK1.5的版本中为我们提供的原子操作包。所谓“原子”操作，是指一组不可分割的操作，操作者对目标对象进行操作时，要么完成所有操作后其他操作者才能操作；要么这个操作者不能进行任何操作。
2.Atomic有什么作用？
原子操作包为我们提供了四类原子操作：
- 原子更新基本类型
- 原子更新数组
- 原子更新引用
- 原子更新字段。
通过这四类，可以有效地解决实际开发中遇到脏数据的问题。
3.原子更新基本类型
原子更新基本类型中有三种操作：
- AtomicBoolean：布尔数据的原子操作
- AtomicInteger：整型数字的原子操作
- AtomicLong：长整型数字的原子操作
下面通过一段代码实现一个AtomicInteger的累加器：
import java.util.concurrent.atomic.AtomicInteger; public class AtomicIntegerDemo { public static void main(String[] args) { Add add = new Add(); Thread t1 = new Thread(add); Thread t2 = new Thread(add); t1.start(); t2.start(); } } class Add implements Runnable { AtomicInteger count = new AtomicInteger(0); @Override public void run() { for (int i = 0; i < 10000; i++) { System.out.println(Thread.currentThread().getName() + " " + count.incrementAndGet()); } } }
从上面的代码我们可以看出，这里并没有使用synchronized就实现了线程安全，这是为什么呢？
我们不妨看一下源码
public final int incrementAndGet() { for (;;) { int current = get(); int next = current + 1; if (compareAndSet(current, next)) return next; } } public final boolean compareAndSet(int expect, int update) { return unsafe.compareAndSwapInt(this, valueOffset, expect, update); }
那源码中为什么是一个死循环呢？
这里要引出两个概念——悲观锁和乐观锁
悲观锁是一种独占锁，它假设的前提是“冲突一定会发生”，所以处理某段可能出现数据冲突的代码时，这个代码段就要被某个线程独占。而独占意味着“其它即将执行这段代码的其他线程”都将进入“阻塞”/“挂起”状态。synchronized关键字就是java对于悲观锁的实现。
乐观锁假定“冲突不一定会出现”，如果出现冲突则进行重试，直到冲突消失。 由于乐观锁的假定条件，所以乐观锁不会独占资源，性能自然在多数情况下就会好于悲观锁，但也会有少数情况坏于悲观锁，就是一旦多线程对某个资源的抢占频度达到了某种规模，就会导致乐观锁内部出现多次更新失败的情况，最终造成乐观锁内部进入一种“活锁”状态。AtomicInteger是一个标准的乐观锁实现。
所以说在incrementAndGet()中，会有一个“死循环”，这是incrementAndGet()方法会有“比较-重试”的过程。
4.原子更新数组
- AtomicIntegerArray：原子操作整型数组
- AtomicLongArray：原子操作长整型数组
- AtomicReferenceArray：原子操作对象引用数组
下面通过一段代码实现一个AtomicIntegerArray的累加器：
import java.util.concurrent.atomic.AtomicIntegerArray; import java.util.concurrent.atomic.AtomicIntegerFieldUpdater; public class AtomicIntegerArrayDemo { public static void main(String[] args) { AddTest add = new AddTest(); Thread[] t = new Thread[10]; for (int i = 0; i < 10; i++) { t[i] = new Thread(add); } for (int i = 0; i < 10; i++) { t[i].start(); } for (int i = 0; i < 10; i++) { try { t[i].join(); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println(add.arr); } static class AddTest implements Runnable { AtomicIntegerArray arr = new AtomicIntegerArray(10); @Override public void run() { for (int i = 0; i < 10000; i++) { arr.getAndIncrement(i % arr.length()); } } } }
我们不妨看一下输出：
由此可知，AtomicIntegerArray是线程安全的。
5.原子更新引用及字段
原子更新对象和字段的操作有：
- AtomicIntegerFieldUpdater：整型数据字段更新器
- AtomicLongFieldUpdater：长型数据字段更新器
- AtomicReferenceFieldUpdater：对象数据字段更新器
- AtomicReference：对象原子操作
我们用AtomicReferenceFieldUpdater更新字段操作：
import java.util.concurrent.atomic.AtomicReferenceFieldUpdater; public class AtomicReferenceUpdaterDemo { public static void main(String[] args) { Student student = new Student(); student.setName("StudentA"); Score score = new Score(); score.setScore(80); student.setScore(score); Score newScore = new Score(); newScore.setScore(90); student.setScore(newScore); System.out.println(student.getName() + ":旧成绩" + score.getScore() + " 新成绩：" + newScore.getScore()); } } class Student { private String name; private volatile Score score; public Student(String name, Score score) { super(); this.name = name; this.score = score; } public Student() { super(); } public String getName() { return name; } public void setName(String name) { this.name = name; } public Score getScore() { return score; } public void setScore(Score score) { score_update.set(this, score); } public AtomicReferenceFieldUpdater<Student, Score> score_update = AtomicReferenceFieldUpdater .newUpdater(Student.class, Score.class, "score"); } class Score { private int score; public Score() { super(); } public Score(int score) { super(); this.score = score; } public int getScore() { return score; } public void setScore(int score) { this.score = score; } }
输出：
下面我们来看一段关于AtomicReference的代码（实现自动充值，当少于20元时，充值20元，再进行消费，每次消费10元）：
import java.util.concurrent.atomic.AtomicReference;
public class AtomicReferenceDemo {
static AtomicReference<Integer> money = new AtomicReference<Integer>(19);
public static void main(String[] args) {
Add add = new Add();
Thread thread1 = new Thread(add);
thread1.start();
Reduce reduce = new Reduce();
Thread thread2 = new Thread(reduce);
thread2.start();
}
static class Add implements Runnable {
@Override
public void run() {
while (true) {
while (true) {
Integer m = money.get();
if (m < 20) {
if (money.compareAndSet(m, m + 20)) {
System.out.println("充值成功，余额:" + money.get() + "元");
break;
}
} else {
break;
}
}
}
}
}
static class Reduce implements Runnable {
@Override
public void run() {
while (true) {
while (true) {
Integer m = money.get();
if (m > 10) {
if (money.compareAndSet(m, m - 10)) {
System.out.println("成功消费10元，余额:" + money.get() + "元");
break;
}
} else {
break;
}
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
它的结果是这样的：
其实这种方法还是可能会出现cas无法判断数据状态的情况，虽然概率不大，但是一般也不采用这种方法。这儿我们先不着急，在我CAS算法和ABA问题的博客中，我们会引出这种现象以及解决方案。
最后，补充两点：
（1）CAS如果长时间不成功，会极大的增加CPU的开销。所以CAS不适合用在复杂的场景。
（2）AtomicIntegerFieldUpdater只能更新int型的数据，并不能Integer数据，要更新Integer数据要使用AtomicReferenceFieldUpdater。
