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 money = new AtomicReference(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。