什么是原子类，原子类有那些，有什么作用

什么是原子类，有什么作用

① 不可分割

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

③ java.util.concurrent.atomic

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

粒度更细：原子变量可以把竞争范围缩小到变量级别，这是我们可以获得的最细的粒度的情况了，通常锁的粒度都要大于原子变量的粒度
效率更高：通常，使用原子类的效率会比使用锁的效率更高，除了高度竞争的情况

6类原子类纵览

Atomic*基本类型原子类，以AtomicInteger为例

1.AtomicInteger方法

2.常用方法

public final int get()//获取当前值

public final int getAndSet(int newValue)//获取当前值，并设置新的值

pubilic final int getAndIncrement()//获取当前值，并自增

pubilic final int getAndDecrement()//获取当前值，并自增

public final int getAndAdd(int delta)//获取当前值，并加上预期值

boolean compareAndSet(int expect,int update)//如果输入的值等于预期值，则以原子方式将该值设置为输入值（update）

/*** 演示AtomicInteger的基本用法，对比原子类的线程安全问题，使用了原子类以后，不需要加锁，也可以保证线程安全问题*/
public class AtomicIntegerDemo1 implements Runnable  {private static final AtomicInteger atomicInteger = new AtomicInteger();public void incrementAtomic(){atomicInteger.getAndIncrement();}private static volatile int basicCount = 0;public /*synchronized*/ void incrementBasic(){//synchronized保证线程安全basicCount++;}public static void main(String[] args) throws InterruptedException {AtomicIntegerDemo1 r = new AtomicIntegerDemo1();Thread thread1 = new Thread(r);Thread thread2 = new Thread(r);thread1.start();thread2.start();thread1.join();thread2.join();System.out.println("原子类的结果是 "+atomicInteger.get());System.out.println("普通变量的结果是 "+basicCount);}@Overridepublic void run() {for (int i = 0; i < 10000; i++) {incrementAtomic();incrementBasic();}}
}

Atomic*Arrray数组类型原子类

/*** 演示原子数组的使用方法*/
public 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++) {threadsIncrementer[i] = new Thread(incrementer);threadsDecrementer[i] = new Thread(decrementer);threadsIncrementer[i].start();threadsDecrementer[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(atomicIntegerArray.get(i));}System.out.println("运行结束");}
}class Decrementer implements Runnable {private AtomicIntegerArray array;public Decrementer(AtomicIntegerArray array) {this.array = array;}@Overridepublic 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;}@Overridepublic void run() {for (int i = 0; i < array.length(); i++) {array.getAndIncrement(i);}}
}

Atomic*Reference引用类型原子类

自旋锁使用

public class SpinLock {private AtomicReference<Thread> sign = new AtomicReference<>();public void lock() {Thread current = Thread.currentThread();while (!sign.compareAndSet(null, current)) {System.out.println("自旋获取失败，再次尝试");}}public void unlock() {Thread current = Thread.currentThread();sign.compareAndSet(current, null);}public static void main(String[] args) {SpinLock spinLock = new SpinLock();Runnable runnable = new Runnable() {@Overridepublic void run() {System.out.println(Thread.currentThread().getName() + "开始尝试获取自旋锁");spinLock.lock();System.out.println(Thread.currentThread().getName() + "获取到了自旋锁");try {Thread.sleep(300);} catch (InterruptedException e) {e.printStackTrace();} finally {spinLock.unlock();System.out.println(Thread.currentThread().getName() + "释放了自旋锁");}}};Thread thread1 = new Thread(runnable);Thread thread2 = new Thread(runnable);thread1.start();thread2.start();}
}

把普通变量升级为原子类

用AtomicIntegerFieldUpdate升级原有变量

public class AtomicIntegerFieldUpdaterDemo implements Runnable {static Candidate tom;static Candidate peter;public static AtomicIntegerFieldUpdater<Candidate> scoreUpdater =AtomicIntegerFieldUpdater.newUpdater(Candidate.class, "score");@Overridepublic void run() {for (int i = 0; i < 10000; i++) {peter.score++;scoreUpdater.getAndIncrement(tom);}}public static class Candidate {volatile int score;//不支持private、static}public static void main(String[] args) throws InterruptedException {tom = new Candidate();peter = new Candidate();AtomicIntegerFieldUpdaterDemo r = new AtomicIntegerFieldUpdaterDemo();Thread thread1 = new Thread(r);Thread thread2 = new Thread(r);thread1.start();thread2.start();thread1.join();thread2.join();System.out.println("普通的变量：" + peter.score);System.out.println("升级后的结果：" + tom.score);}
}

注意点：

① 可见范围：变量不能为private

② 不支持static

Adder累加器

① java8引入的，相比较是一个比较新的类

② 高并发下LogAdder比AtomicLog效率高，不过本质是空间换时间

③ 竞争激烈的时候，LongAdder把不同线程对应到不同的Cell上进行修改，降低了冲突的概率，是多段锁的理念，提高了并发性

④ LongAdder适合的场景是统计求和计数的场景，而且LongAdder基本只提供了add方法，而AtomicLong还具有cas方法

演示多线程下AtomicLong的性能，有20个线程对同一个AtomicLong累加（由于竞争很激烈，每一次加法，都要flush和refresh,导致很耗费资源）

/*** 演示高并发场景下，LongAdder比AtomicLong性能好*/
@SuppressWarnings("all")
public class AtomicLongDemo {public static void main(String[] args) throws InterruptedException {AtomicLong counter = new AtomicLong();ExecutorService service = Executors.newFixedThreadPool(20);long start = System.currentTimeMillis();for (int i = 0; i < 10000; i++) {service.submit(new Task(counter));}service.shutdown();while (!service.isTerminated()) {}long end = System.currentTimeMillis();System.out.println(counter.get());System.out.println("AtomicLon耗时：" + (end - start));}private static class Task implements Runnable {private AtomicLong counter;public Task(AtomicLong counter) {this.counter = counter;}@Overridepublic void run() {for (int i = 0; i < 10000; i++) {counter.incrementAndGet();}}}
}

LongAdder演示

@SuppressWarnings("all")
public class AtomicAdderDemo {public static void main(String[] args) throws InterruptedException {LongAdder counter = new LongAdder();ExecutorService service = Executors.newFixedThreadPool(20);long start = System.currentTimeMillis();for (int i = 0; i < 10000; i++) {service.submit(new Task(counter));}service.shutdown();while (!service.isTerminated()) {}long end = System.currentTimeMillis();System.out.println(counter.sum());System.out.println("LongAdder耗时："+(end-start));}private static class Task implements Runnable {private LongAdder counter;public Task(LongAdder counter) {this.counter = counter;}@Overridepublic void run() {for (int i = 0; i < 10000; i++) {counter.increment();}}}
}

累加结果耗时显示

LongAdder改进和原理：

① 在内部，这个LongAdder的实现原理和刚才的AtomicLong是不同的，刚才的AtomicLong的实现原理是，每一次加法都需要做同步，所以在高并发的时候会导致冲突比较多，也就降低了效率

② 而此时的LongAdder,每个线程都有一个计数器，仅用来在自己的线程内计算，这样一来就不会和其他线程的计数器干扰

③ 如上图，第一个线程的计数器的数值，也就是ctr’,为1的时候，可能线程2的计数器ctr’’的数值已经是3了，他们之间并不存在竞争关系，所以在加和的过程中，根本不需要同步机制，也不需要刚才的flush和reflush。这里没有一个公共的counter来给所有线程统一计数

④ LongAdder引入了分段累加的概念，内部有一个base变量和一个Cell[]数组共同参与计数：

base变量：竞争不激烈，直接累加到该变量上
Cell[]:竞争激烈，各个线程分散累加到自己的槽Cell[i]中，

⑤ sum源码

 public long sum() {Cell[] as = cells; Cell a;long sum = base;if (as != null) {for (int i = 0; i < as.length; ++i) {if ((a = as[i]) != null)sum += a.value;}}return sum;}

Accumulator累加器

public class LongAccumulatorDemo {public static void main(String[] args) {LongAccumulator accumulator = new LongAccumulator((x,y)->x+y,0);ExecutorService executor = Executors.newFixedThreadPool(8);IntStream.range(1,10).forEach(i->executor.submit(()->accumulator.accumulate(i)));executor.shutdown();while (!executor.isTerminated()){}System.out.println(accumulator.getThenReset());}
}

使用场景：

① 适用于需要大量计算，并且需要并行计算的场景，如果不需要并行计算，可用for循环解决问题，用了Accumulator累加器可利用多核同时计算，提供效率

② 计算的顺序不能成为瓶颈，线程1可能在线程5之后运行，也可能在之前运行，不影响最终结果