并发安全工具类（6）：原子类

蔚落 2023-07-02 05:25 78阅读 0赞

# 1 什么是原子类，有什么作用？ #

>  *  不可分割
>  *  一个操作是不可中断的，即便是多线程的情况下也可以保证
>  *  java.util.concurrent.atomic
>  *  原子类的作用和锁类似，是为了保证并发情况下线程安全
>  *  粒度更细：原子变量可以把竞争范围缩小到变量级别，这是我们可以获得的**最细粒度的情况**了，通常锁的粒度都要大于原子变量的粒度（原子类相比于锁，有一定的优势）
>  *  效率更高：通常，使用原子类的效率会比使用锁的效率更高，除了高度竞争的情况

--------------------

# 2 6类原子类纵览 #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70][]

--------------------

# 3 Atomic\*基本类型原子类，AtomicInteger为例 #

>  *  AtomicInteger：整形原子类
>  *  AtomicLong：长整型原子类
>  *  AtomicBoolean：布尔型原子类

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

/**
     * 演示AtomicInteger的基本用法，对比非原子类的线程安全问题，使用了原子类之后，不需要加锁，也可以保证线程安全。
     */
    public class AtomicIntegerDemo1 implements Runnable {
        private static final AtomicInteger atomicInteger = new AtomicInteger();
        private static volatile int basicCount = 0;
        public void incrementAtomic() {
            //正数就是每次都相加delta getAndAdd(1) == getAndIncrement()
            //负数就是每次都相减delta getAndAdd(-1) == getAndDecrement()
            atomicInteger.getAndAdd(1);
        }
        //public synchronized void incrementBasic() {
        //    basicCount++;
        //}
        public void incrementBasic() {
            basicCount++;
        }
        public static void main(String[] args) throws InterruptedException {
            AtomicIntegerDemo1 r = new AtomicIntegerDemo1();
            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);
        }
        @Override
        public void run() {
            for (int i = 0; i < 10000; i++) {
                incrementAtomic();
                incrementBasic();
            }
        }
    }

--------------------

# 4 AtomicBoolean #

public class AtomicAtomicBooleanExample {
        private static AtomicBoolean isHappened = new AtomicBoolean(false);
        // 请求总数
        public static int clientTotal = 5000;
        // 同时并发执行的线程数
        public static int threadTotal = 200;
    
        public static void main(String[] args) throws Exception {
            ExecutorService executorService = Executors.newCachedThreadPool();
            final CountDownLatch begin = new CountDownLatch(1);
            for (int i = 0; i < clientTotal; i++) {
                executorService.execute(() -> {
                    try {
                        begin.await();
                        //System.out.println(Thread.currentThread().getName() + "开始执行test方法");
                        test();
                    } catch (InterruptedException e) {
                        System.out.println("interruptedException");
                    }
                });
            }
            Thread.sleep(3000);
            begin.countDown();
            executorService.shutdown();
            System.out.println("isHappened:" + isHappened.get());
        }
        private static void test() {
            if (isHappened.compareAndSet(false, true)) {
                //里面的方法只会执行一次
                System.out.println("execute");
            }
        }
    }

--------------------

# 4 Atomic\*Array数组类型原子类 #

/**
     * 演示原子数组的使用方法
     */
    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++) {
                threadsDecrementer[i] = new Thread(decrementer);
                threadsIncrementer[i] = new Thread(incrementer);
                threadsDecrementer[i].start();
                threadsIncrementer[i].start();
            }
            //Thread.sleep(10000);
            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;
        }
        @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);
            }
        }
    }

--------------------

# 5 Atomic\*Reference引用类型原子类 #

> AtomicReference：AtomicReference类的作用，和AtomicInteger并没有本质区别，AtomicInteger可以让一个整数保证原子性，而AtomicReference可以让一个对象保证原子性，当然，AtomicReference的功能明显比AtomicInteger强，因为一个对象里可以包含很多属性。用法和AtomicInteger类似。

@Slf4j
    public class AtomicExample4 {
        private static AtomicReference<Integer> count = new AtomicReference<>(0);
        public static void main(String[] args) {
            count.compareAndSet(0, 2); // 2
            count.compareAndSet(0, 1); // no
            count.compareAndSet(1, 3); // no
            count.compareAndSet(2, 4); // 4
            count.compareAndSet(3, 5); // no
            log.info("count:{}", count.get());//4
        }
    }

@Data
    class User {
        private String username;
        private Integer age;
        public User() {}
        public User(String username, Integer age) {
            this.username = username;
            this.age = age;
        }
    }
    public class AtomicReferenceDemo {
        public static void main(String[] args) {
            User zs = new User("张三", 18);
            User li = new User("李四", 20);
            AtomicReference<User> reference = new AtomicReference<>();
            reference.set(zs);
            System.out.println(reference.compareAndSet(zs, li) + " => " + reference.get().toString());
            System.out.println(reference.compareAndSet(zs, li) + " => " + reference.get().toString());
        }
    }

> [https://yuanyu.blog.csdn.net/article/details/104082917\#t6][https_yuanyu.blog.csdn.net_article_details_104082917_t6]

--------------------

# 6 把普通变量升级为原子类：用AtomicIntegerFieldUpdater升级原有变量 #

>  *  AtomicIntegerFieldUpdater对普通变量进行升级
>  *  使用场景：偶尔需要一个原子get-set操作

/**
     * 演示AtomicIntegerFieldUpdater的用法
     */
    public class AtomicIntegerFieldUpdaterDemo implements Runnable{
        static Candidate tom;
        static Candidate peter;
        public static AtomicIntegerFieldUpdater<Candidate> scoreUpdater = AtomicIntegerFieldUpdater.newUpdater(Candidate.class, "score");
        @Override
        public void run() {
            for (int i = 0; i < 10000; i++) {
                peter.score++;
                scoreUpdater.getAndIncrement(tom);
            }
        }
        //候选人
        public static class Candidate {
            //分数
            volatile int score;
        }
        public static void main(String[] args) throws InterruptedException {
            tom=new Candidate();
            peter=new Candidate();
            AtomicIntegerFieldUpdaterDemo r = new AtomicIntegerFieldUpdaterDemo();
            Thread t1 = new Thread(r);
            Thread t2 = new Thread(r);
            t1.start();
            t2.start();
            t1.join();
            t2.join();
            System.out.println("普通变量："+peter.score);
            System.out.println("升级后的结果"+ tom.score);
        }
    }

@Slf4j
    public class AtomicExample5 {
        //原子性的去更新某一个类的实例指定的某一个字段
        private static AtomicIntegerFieldUpdater<AtomicExample5> updater = AtomicIntegerFieldUpdater.newUpdater(AtomicExample5.class, "count");
        //volatile修饰的非static的字段
        @Getter
        public volatile int count = 100;
        public static void main(String[] args) {
            AtomicExample5 example5 = new AtomicExample5();
            //如果example5里面的count是100就更新为120
            if (updater.compareAndSet(example5, 100, 120)) {
                log.info("update success 1, {}", example5.getCount());
            }
            if (updater.compareAndSet(example5, 100, 120)) {
                log.info("update success 2, {}", example5.getCount());
            } else {
                log.info("update failed, {}", example5.getCount());
            }
        }
    }

>  AtomicIntegerFieldUpdater注意点
> 
>  *  可见范围：利用的反射修饰符不能是private
>  *  不支持static：IllegalArgumentException

--------------------

# 7 Adder累加器 #

>  *  是Java 8引入的，相对是比较新的一个类
>  *  高并发下LongAdder比AtomicLong效率高，不过本质是空间换时间
>  *  竞争激烈的时候，LongAdder把不同线程对应到不同的Cell上进行修改，降低了冲突的概率，是多段锁的理念，提高了并发性

>  *  代码演示
>  *  这里演示多线程情况下AtomicLong的性能
>  *  由于竞争很激烈，每一次加法，都要flush和refresh，导致很耗费资源。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 1][]

/**
     * 演示高并发场景下，LongAdder比AtomicLong性能好
     */
    public class AtomicLongDemo {
        public static void main(String[] args) throws InterruptedException {
            AtomicLong counter = new AtomicLong(0);
            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("AtomicLong耗时：" + (end - start));//2229
        }
        private static class Task implements Runnable {
            private AtomicLong counter;
            public Task(AtomicLong counter) {
                this.counter = counter;
            }
            @Override
            public void run() {
                for (int i = 0; i < 10000; i++) {
                    counter.incrementAndGet();
                }
            }
        }
    }

/**
     * 演示高并发场景下，LongAdder比AtomicLong性能好
     */
    public class LongAdderDemo {
        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));//244
        }
        private static class Task implements Runnable {
            private LongAdder counter;
            public Task(LongAdder counter) {
                this.counter = counter;
            }
            @Override
            public void run() {
                for (int i = 0; i < 10000; i++) {
                    counter.increment();
                }
            }
        }
    }

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 2][]

>  *  LongAdder，每个线程会有自己的一个计数器，仅用来在自己线程内计数，这样一来就不会和其他线程的计数器干扰
>  *  如图中所示，第一个线程的计数器数值，也就是**ctr′**，为1的时候，可能线程2的计数器**ctr′′**的数值已经是3了，他们之间并不存在竞争关系所以在加和的过程中，根本不需要同步机制，也不需要刚才的flush和refresh。这里也没有—个公共的counter来给所有线程统一计数

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 3][]

> LongAdder引入了分段累加的概念，内部有一个base变量和一个Cell\[\]数组共同参与计数
> 
>  *  base变量：竞争不激烈，直接累加到该变量上
>  *  Cell\[\]数组：竞争激烈，各个线程分散累加到自己的槽Cell\[i\]中

> sum源码分析

//java.util.concurrent.atomic.LongAdder#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;
    }

>  对比AtomicLong和LongAdder
> 
>  *  在低争用下，AtomicLong和LongAdder这两个类具有相似的特征。但是在竞争激烈的情况下，LongAdder的预期吞吐量要高得多，但要消耗更多的空间
>  *  LongAdder适合的场景是统计求和计数的场景，而且LongAdder基本只提供了add方法，而AtomicLong还具有cas方法

--------------------

# 8 Accumulator累加器 #

> Accumulator和Adder非常相似，Accumulator就是一个更通用版本的Adder
> 
> 使用场景：大量并行计算，对计算顺序不能有要求（不影响最后结果）

/**
     * 演示LongAccumulator的用法
     */
    public class LongAccumulatorDemo {
        public static void main(String[] args) {
            //x是传入的，y是初始值或者上一次计算的值
            LongAccumulator accumulator = new LongAccumulator((x, y) -> 2 + x * y, 1);
            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());
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200126202937161.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[https_yuanyu.blog.csdn.net_article_details_104082917_t6]: https://yuanyu.blog.csdn.net/article/details/104082917#t6
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200126222338661.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/2020012622272625.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200126223020566.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70