目录

什么是原子类，作用？

6类原子类纵览:

AtomicInteger?常用方法

AtomicInArray 使用实例：

Atomic*Reference 引用类型原子类：

?

什么是原子类，作用？

• java.util.concurrent.atomic 包下的类

• 不可分割的，且一个操作是不可中断的，即便是多线程的情况下也可以保证

• 原子类的作用和锁类似，是为了保证并发情况下线程安全，不过原子类相比于锁，有一定的优势

• 粒度更细：原子变量可以把竞争范围缩小到变量级别，这是我们可以获得的最细粒度的情况了，通常锁的力度都要大于原子变量的粒度

• 效率更高：通常，使用原子类的效率会比使用锁的效率更高，除了高度竞争的情况

6类原子类纵览:

AtomicInteger?常用方法

• public final int get() ?// 获取当前的值
• public final int getAndSet(int newValue) // 获取当前的值，并自增
• public final int getAndDecrement() // 获取当前的值，并自减
• public final int getAndAdd(int delta) // 获取当前的值，并加上预期的值
• boolean compareAndSet(int expect, int update) //如果输入的数值等于预期值，则以原子方式将该值设置为输入值(update)

/**
 * 描述：演示AtomicInteger的基本用法，对比非原子类的线程安全问题
 *      使用了原子类之后，不需要加锁，也可以保证线程安全问题
 */
public class AtomicIntegerDemo implements Runnable{
    public static final AtomicInteger atomicInteger = new AtomicInteger();

    public void incrementAtomic(){
        atomicInteger.getAndIncrement();
    }

    public static volatile int basicCount = 0;

    public void incrementBasic(){
        basicCount++;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            incrementAtomic();
            incrementBasic();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        AtomicIntegerDemo r = new AtomicIntegerDemo();
        Thread t1 = new Thread(r);
        Thread t2 = new Thread(r);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("原子类的结果："+atomicInteger.get());
        System.out.println("普通的结果："+basicCount);
    }
}

执行结果：
原子类的结果：20000
普通的结果：19980

AtomicInArray 使用实例：

/**
 * 描述：演示原子数组使用
 */
class AtomicArrayDemo{
    public static void main(String[] args) {
        AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(1000);
        Incrementer incrementer = new Incrementer(atomicIntegerArray);
        Decrementer decrementer = new Decrementer(atomicIntegerArray);
        Thread[] threadsIncrementer = new Thread[100];
        Thread[] threadsDecrementer = new Thread[100];
        for (int i = 0; i < 100; i++) {
            threadsDecrementer[i] = new Thread(decrementer);
            threadsIncrementer[i] = new Thread(incrementer);
            threadsDecrementer[i].start();
            threadsIncrementer[i].start();
        }
        for (int i = 0; i < 100; i++) {
            try {
                threadsDecrementer[i].join();
                threadsIncrementer[i].join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        for (int i = 0; i < atomicIntegerArray.length(); i++) {
            if (atomicIntegerArray.get(i) != 0){
                System.out.println("发现了错误"+i);
            }
        }
        System.out.println("运行结束");
    }
}
class Decrementer implements Runnable{

    private AtomicIntegerArray array;

    public Decrementer(AtomicIntegerArray array) {
        this.array = array;
    }

    @Override
    public void run() {
        for (int i = 0; i < array.length(); i++) {
            array.getAndDecrement(i);
        }
    }
}

class Incrementer implements Runnable{

    private AtomicIntegerArray array;

    public Incrementer(AtomicIntegerArray array) {
        this.array = array;
    }

    @Override
    public void run() {
        for (int i = 0; i < array.length(); i++) {
            array.getAndIncrement(i);
        }
    }
}

Atomic*Reference 引用类型原子类：
?

AtomicReference: AtomicReference类的作用和AtomicInteger并没有本质区别，AtomicInteger可以让一个整数保证原子性，而AtomicReference可以让一个对象保证原子性

上一篇的自旋锁演示就是通过它实现的

?