atomic

左手的ㄟ右手 2022-09-12 11:47 354阅读 0赞

# 原子操作 #

原子（atomic）本意是“不能被进一步分割的最小粒子”，而原子操作（atomic operation）意  
为“不可被中断的一个或一系列操作”。

## 处理器如何实现原子操作 ##

最新的处理器能自动保证单处理器对同一个缓存行里进行16/32/64位的操作是原子的，但是复杂的内存操作处理器是不能自动保证其原子性的，比如跨总线宽度、跨多个缓存行和跨页表的访问。但是，处理器提供总线锁定和缓存锁定两个机制来保证复杂内存操作的原子性。

### 使用总线锁保证原子性 ###

如果多个处理器同时对共享变量进行读改写操作  
（i++就是经典的读改写操作），那么共享变量就会被多个处理器同时进行操作，这样读改写操  
作就不是原子的，操作完之后共享变量的值会和期望的不一致。举个例子，如果i=1，我们进行  
两次i++操作，我们期望的结果是3，但是有可能结果是2，

![image-20210910091045867][]

原因可能是多个处理器同时从各自的缓存中读取变量i，分别进行加1操作，然后分别写入  
系统内存中。那么，想要保证读改写共享变量的操作是原子的，就必须保证CPU1读改写共享  
变量的时候，CPU2不能操作缓存了该共享变量内存地址的缓存。

### 使用缓存锁保证原子性 ###

频繁使用的内存会缓存在处理器的L1、L2和L3高速缓存里，那么原子操作就可以直接在处理器内部缓存中进行，并不需要声明总线锁，在Pentium 6和目前的处理器中可以使用“缓存锁定”的方式来实现复杂的原子性。所谓“缓存锁定”是指内存区域如果被缓存在处理器的缓存行中，并且在Lock操作期间被锁定，那么当它执行锁操作回写到内存时，会修改内部的内存地址，并允许它的缓存一致性机制来保证操作的原子性，因为缓存一致性机制会阻止同时修改由两个以上处理器缓存的内存区域数据，当其他处理器回写已被锁定的缓存行的数据时，会使缓存行无效，当CPU1修改缓存行中的i时使用了缓存锁定，那么CPU2就不能同时缓存i的缓存行。

## Java如何实现原子操作 ##

在Java中可以通过锁和循环CAS的方式来实现原子操作。

### 使用循环CAS实现原子操作 ###

JVM中的CAS操作正是利用了处理器提供的CMPXCHG指令实现的。自旋CAS实现的基本思路就是循环进行CAS操作直到成功为止，

从Java 1.5开始，JDK的并发包里提供了一些类来支持原子操作，如AtomicBoolean（用原子方式更新的boolean值）、AtomicInteger（用原子方式更新的int值）和AtomicLong（用原子方式更新的long值）。这些原子包装类还提供了有用的工具方法，比如以原子的方式将当前值自增1和自减1。

CAS实现原子操作的三大问题  
在Java并发包中有一些并发框架也使用了自旋CAS的方式来实现原子操作，比如  
LinkedTransferQueue类的Xfer方法。CAS虽然很高效地解决了原子操作，但是CAS仍然存在三  
大问题。ABA问题，循环时间长开销大，以及只能保证一个共享变量的原子操作。

### 使用锁机制实现原子操作 ###

锁机制保证了只有获得锁的线程才能够操作锁定的内存区域。JVM内部实现了很多种锁机制，有偏向锁、轻量级锁和互斥锁。有意思的是除了偏向锁，JVM实现锁的方式都用了循环CAS，即当一个线程想进入同步块的时候使用循环CAS的方式来获取锁，当它退出同步块的时候使用循环CAS释放锁

# atomic #

![d4ade015b68c2edbc4cb6b66b894f957.png][]

## 基本类型原子类 ##

**AtomicInteger**

**AtomicBoolean**

**AtomicLong**

### 常用API ###

以 AtomicInteger 为例

AtomicInteger i = new AtomicInteger(0);
    // 获取并自增（i = 0, 结果 i = 1, 返回 0），类似于 i++
    System.out.println(i.getAndIncrement());
    // 自增并获取（i = 1, 结果 i = 2, 返回 2），类似于 ++i
    System.out.println(i.incrementAndGet());
    // 自减并获取（i = 2, 结果 i = 1, 返回 1），类似于 --i
    System.out.println(i.decrementAndGet());
    // 获取并自减（i = 1, 结果 i = 0, 返回 1），类似于 i--
    System.out.println(i.getAndDecrement());
    // 获取并加值（i = 0, 结果 i = 5, 返回 0）
    System.out.println(i.getAndAdd(5));
    // 加值并获取（i = 5, 结果 i = 0, 返回 0）
    System.out.println(i.addAndGet(-5));
    // 获取并更新（i = 0, p 为 i 的当前值, 结果 i = -2, 返回 0）
    // 其中函数中的操作能保证原子，但函数需要无副作用
    System.out.println(i.getAndUpdate(p -> p - 2));
    // 更新并获取（i = -2, p 为 i 的当前值, 结果 i = 0, 返回 0）
    // 其中函数中的操作能保证原子，但函数需要无副作用
    System.out.println(i.updateAndGet(p -> p + 2));
    // 获取并计算（i = 0, p 为 i 的当前值, x 为参数1, 结果 i = 10, 返回 0）
    // 其中函数中的操作能保证原子，但函数需要无副作用
    // getAndUpdate 如果在 lambda 中引用了外部的局部变量，要保证该局部变量是 final 的
    // getAndAccumulate 可以通过 参数1 来引用外部的局部变量，但因为其不在 lambda 中因此不必是 final
    System.out.println(i.getAndAccumulate(10, (p, x) -> p + x));
    // 计算并获取（i = 10, p 为 i 的当前值, x 为参数1, 结果 i = 0, 返回 0）
    // 其中函数中的操作能保证原子，但函数需要无副作用
    System.out.println(i.accumulateAndGet(-10, (p, x) -> p + x));
    
    
    boolean compareAndSet(int expect, int update) //如果输入的数值等于预期值，则以原子方式将该值设置为输入值（update）

### 实例 ###

atomicInteger实现50000次的自增

使用CountDownLatch保证50个线程执行完再输出结果，不然50个线程还没执行完，主线程就退出了

就可以不用sleep了，sleep无法精确保证50个线程执行完就输出结果。正好回顾下CountDownLatch在多线程的使用

package com.dongguo.atomic;
    
    import lombok.Getter;
    
    import java.util.concurrent.CountDownLatch;
    import java.util.concurrent.atomic.AtomicInteger;
    
    /** * @author Dongguo * @date 2021/9/7 0007-13:41 * @description: */
    
    class MyNumber { 
        @Getter
        private AtomicInteger atomicInteger = new AtomicInteger();
    
        public void addPlusPlus() { 
            atomicInteger.incrementAndGet();
        }
    }
    
    public class AtomicIntegerDemo { 
        public static void main(String[] args) { 
            MyNumber myNumber = new MyNumber();
            final Integer THREAD_SIZE = 50;
            CountDownLatch countDownLatch = new CountDownLatch(THREAD_SIZE);
            for (int i = 1; i <= THREAD_SIZE; i++) { 
                new Thread(() -> { 
                    try { 
                        for (int j = 0; j < 1000; j++) { 
                            myNumber.addPlusPlus();
                        }
                    } finally { 
                        countDownLatch.countDown();
                    }
                }, "t" + i).start();
            }
            try { 
                //保证50个线程执行完再输出结果，不然50个线程还没执行完，主线程就退出了
                countDownLatch.await();
                System.out.println(myNumber.getAtomicInteger().get());
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
        }
    }
    运行结果
    50000

这些方法只能实现+1，-1的操作，如果我想实现自定义乘法、除法的运算怎么办呢？

可以使用updateAndGet(updateFunction)

package com.dongguo.atomic;
    
    import java.util.concurrent.atomic.AtomicInteger;
    
    /** * @author Dongguo * @date 2021/9/12 0012-18:39 * @description: */
    public class AtomicIntegerDemo2 { 
        public static void main(String[] args) { 
            AtomicInteger atomicInteger = new AtomicInteger(10);
            int result = atomicInteger.updateAndGet(x -> x * 10);
            System.out.println(result);
        }
    }
    运行结果
    100

## 数组类型原子类 ##

**AtomicIntegerArray**

**AtomicLongArray**

**AtomicReferenceArray**

### 实例 ###

package com.dongguo.atomic;
    
    import java.util.concurrent.atomic.AtomicIntegerArray;
    
    /** * @author Dongguo * @date 2021/9/7 0007-13:56 * @description: */
    public class AtomicIntegerArrayDemo { 
        public static void main(String[] args) { 
            AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(new int[]{ 1,2,3,4,5});
            for (int i = 0; i < atomicIntegerArray.length(); i++) { 
                System.out.println(atomicIntegerArray.get(i));
            }
    
            atomicIntegerArray.getAndSet(0,10);
            System.out.println(atomicIntegerArray.get(0));
    
            atomicIntegerArray.getAndIncrement(1);
            System.out.println(atomicIntegerArray.get(1));
            int result = atomicIntegerArray.getAndIncrement(1);
            System.out.println(result+"\t"+atomicIntegerArray.get(1));
        }
    }
    运行结果
    1
    2
    3
    4
    5
    10
    3
    3	4

## 引用类型原子类 ##

**AtomicReference**

**AtomicStampedReference**

**AtomicMarkableReference**

### **AtomicReference** ###

import lombok.AllArgsConstructor;
    import lombok.Getter;
    import lombok.ToString;
    
    import java.util.concurrent.atomic.AtomicReference;
    
    @Getter
    @ToString
    @AllArgsConstructor
    class User
    { 
        String userName;
        int    age;
    }
    
    public class AtomicReferenceDemo
    { 
        public static void main(String[] args)
        { 
            User z3 = new User("z3",24);
            User li4 = new User("li4",26);
    
            AtomicReference<User> atomicReferenceUser = new AtomicReference<>();
    
            atomicReferenceUser.set(z3);
            System.out.println(atomicReferenceUser.compareAndSet(z3,li4)+"\t"+atomicReferenceUser.get().toString());
            System.out.println(atomicReferenceUser.compareAndSet(z3,li4)+"\t"+atomicReferenceUser.get().toString());
        }
    }

自旋锁SpinLockDemo中使用AtomicReference

import java.util.concurrent.TimeUnit;
    import java.util.concurrent.atomic.AtomicReference;
    
    /** * 题目：实现一个自旋锁 * 自旋锁好处：循环比较获取没有类似wait的阻塞。 * * 通过CAS操作完成自旋锁，A线程先进来调用myLock方法自己持有锁5秒钟，B随后进来后发现 * 当前有线程持有锁，不是null，所以只能通过自旋等待，直到A释放锁后B随后抢到。 */
    public class SpinLockDemo
    { 
        AtomicReference<Thread> atomicReference = new AtomicReference<>();
    
        public void myLock()
        { 
            Thread thread = Thread.currentThread();
            System.out.println(Thread.currentThread().getName()+"\t come in");
            while(!atomicReference.compareAndSet(null,thread))
            { 
    
            }
        }
    
        public void myUnLock()
        { 
            Thread thread = Thread.currentThread();
            atomicReference.compareAndSet(thread,null);
            System.out.println(Thread.currentThread().getName()+"\t myUnLock over");
        }
    
        public static void main(String[] args)
        { 
            SpinLockDemo spinLockDemo = new SpinLockDemo();
    
            new Thread(() -> { 
                spinLockDemo.myLock();
                //暂停一会儿线程
                try {  TimeUnit.SECONDS.sleep( 5 ); } catch (InterruptedException e) {  e.printStackTrace(); }
                spinLockDemo.myUnLock();
            },"A").start();
            //暂停一会儿线程，保证A线程先于B线程启动并完成
            try {  TimeUnit.SECONDS.sleep( 1 ); } catch (InterruptedException e) {  e.printStackTrace(); }
    
            new Thread(() -> { 
                spinLockDemo.myLock();
                spinLockDemo.myUnLock();
            },"B").start();
    
        }
    }

### **AtomicStampedReference** ###

**携带版本号的引用类型原子类，可以解决CAS中的ABA问题**

让我们知道引用变量中途被更改了几次

package com.dongguo.cas;
    
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.atomic.AtomicInteger;
    import java.util.concurrent.atomic.AtomicStampedReference;
    
    /** * @author Dongguo * @date 2021/9/7 0007-12:48 * @description: */
    public class ABADemo { 
        public static void main(String[] args) { 
            AtomicStampedReference atomicStampedReference = new AtomicStampedReference(10, 1);
            new Thread(() -> { 
                int stamp = atomicStampedReference.getStamp();//首次版本号
                System.out.println(Thread.currentThread().getName() + " 1首次版本号" + stamp + "值为" + atomicStampedReference.getReference());
                //保证t1、t2得到相同版本号
                try { 
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                atomicStampedReference.compareAndSet(10, 100, stamp, stamp + 1);
                stamp = atomicStampedReference.getStamp();
                System.out.println(Thread.currentThread().getName() + " 2次版本号" + stamp + "值为" + atomicStampedReference.getReference());
                atomicStampedReference.compareAndSet(100, 10, stamp, stamp + 1);
                stamp = atomicStampedReference.getStamp();
                System.out.println(Thread.currentThread().getName() + " 3次版本号" + stamp + "值为" + atomicStampedReference.getReference());
            }, "t1").start();
            //保证t1发生在t2之前
            try { 
                TimeUnit.MILLISECONDS.sleep(500);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            new Thread(() -> { 
                int stamp = atomicStampedReference.getStamp();//首次版本号
                System.out.println(Thread.currentThread().getName() + " 1首次版本号" + stamp + "值为" + atomicStampedReference.getReference());
                //保证t1、t2得到相同版本号 并且t1发生ABA问题
                try { 
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                boolean result = atomicStampedReference.compareAndSet(10, 123, stamp, stamp + 1);
                System.out.println(Thread.currentThread().getName() + "修改结果为" + result + " 值为" + atomicStampedReference.getReference());
            }, "t2").start();
        }
    }

### **AtomicMarkableReference** ###

**原子更新带有标记位的引用类型对象**

它的定义就是将状态戳简化为true|false 只能解决一次性问题

**不建议使用AtomicMarkableReference解决ABA问题**

它不关心引用变量更改过几次，只关心是否更改过

package com.dongguo.atomic;
    
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.atomic.AtomicMarkableReference;
    
    /** * @author Dongguo * @date 2021/9/7 0007-14:14 * @description: */
    public class AtomicMarkableReferenceDemo { 
        public static void main(String[] args) { 
            AtomicMarkableReference atomicMarkableReference = new AtomicMarkableReference(1,false);
    
            new Thread(()->{ 
                boolean marked = atomicMarkableReference.isMarked();
                System.out.println(Thread.currentThread().getName()+"修改标志为"+marked);
                try { 
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                atomicMarkableReference.compareAndSet(1,100,marked,!marked);
                System.out.println("值为"+atomicMarkableReference.getReference());
            },"t1").start();
    
            try { 
                TimeUnit.MILLISECONDS.sleep(200);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
    
            new Thread(()->{ 
                boolean marked = atomicMarkableReference.isMarked();
                System.out.println(Thread.currentThread().getName()+"修改标志为"+marked);
                try { 
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                boolean result = atomicMarkableReference.compareAndSet(1, 123, marked, !marked);
                System.out.println("修改结果"+result);
                System.out.println(Thread.currentThread().getName()+"修改标志为"+atomicMarkableReference.isMarked());
                System.out.println("值为"+atomicMarkableReference.getReference());
            },"t2").start();
        }
    }
    t1修改标志为false
    t2修改标志为false
    值为100
    修改结果false
    t2修改标志为true
    值为100

## 对象的属性修改原子类（字段更新器） ##

\*\*AtomicIntegerFieldUpdater \*\*原子更新对象中int类型字段的值

**AtomicLongFieldUpdater**原子更新对象中Long类型字段的值

**AtomicReferenceFieldUpdater**原子更新引用类型字段的值

利用字段更新器，可以针对对象的某个域（Field）进行原子操作，只能配合 volatile 修饰的字段使用，否则会出现异常

Exception in thread "main" java.lang.IllegalArgumentException: Must be volatile type

**作用**：以一种线程安全的方式操作非线程安全对象内的某些字段

如果使用锁，需要锁定整个对象

synchronized(obj){ 
    	//需要锁定整个对象
    }

比如银行卡，有卡号、开户地址、户主、电话、余额等属性，只有余额是经常变化的

我们可以使用对象的属性修改原子类 ，不用锁定整个对象，只锁定敏感性变化的某一个字段。

达到精确加锁，细粒度处理，节约内存的目的

**要求：**

1更新的对象属性必须使用 public volatile 修饰符。

2因为对象的属性修改类型原子类都是抽象类，所以每次使用都必须使用静态方法newUpdater()创建一个更新器，并且需要设置想要更新的类和属性。

### AtomicIntegerFieldUpdater ###

package com.dongguo.atomic;
    
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
    
    /** * @author Dongguo * @date 2021/9/7 0007-14:41 * 以一种线程安全的方式操作非线程安全对象的某些字段。 * 需求： * 1000个人同时向一个账号转账一元钱，那么累计应该增加1000元， * 除了synchronized和CAS,还可以使用AtomicIntegerFieldUpdater来实现。 */
    class BankAccount { 
        private String bankName = "ACBC";
        public volatile int money = 0;
        AtomicIntegerFieldUpdater<BankAccount> fieldUpdater = AtomicIntegerFieldUpdater.newUpdater(BankAccount.class, "money");
    
        public void transferMoney(BankAccount bankAccount) { 
            fieldUpdater.incrementAndGet(bankAccount);
        }
    }
    
    public class AtomicIntegerFieldUpdaterDemo { 
        public static void main(String[] args) { 
            BankAccount bankAccount = new BankAccount();
    
            for (int i = 1; i <= 1000; i++) { 
                new Thread(() -> { 
                    bankAccount.transferMoney(bankAccount);
                }, String.valueOf(i)).start();
            }
            //暂停毫秒
            try { 
                TimeUnit.MILLISECONDS.sleep(500);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            System.out.println(bankAccount.money);
        }
    }
    运行结果
    1000

扩展：

很多开源框架中，例如Netty中好多地方都用到了AtomicIntegerFieldUpdater。

比如AbstractReferenceCountedByteBuf 类中定义了一个refCntUpdater:

private static final AtomicIntegerFieldUpdater<AbstractReferenceCountedByteBuf> refCntUpdater;
    
        static { 
            AtomicIntegerFieldUpdater<AbstractReferenceCountedByteBuf> updater =
                    PlatformDependent.newAtomicIntegerFieldUpdater(AbstractReferenceCountedByteBuf.class, "refCnt");
            if (updater == null) { 
                updater = AtomicIntegerFieldUpdater.newUpdater(AbstractReferenceCountedByteBuf.class, "refCnt");
            }
            refCntUpdater = updater;
        }

refCntUpdater 是Netty用来记录ByteBuf被引用的次数，会出现并发的操作，比如增加一个引用关系，减少一个引用关系，其retain方法，实现了refCntUpdater的自增：

private ByteBuf retain0(int increment) { 
            for (;;) { 
                int refCnt = this.refCnt;
                final int nextCnt = refCnt + increment;
    
                // Ensure we not resurrect (which means the refCnt was 0) and also that we encountered an overflow.
                if (nextCnt <= increment) { 
                    throw new IllegalReferenceCountException(refCnt, increment);
                }
                if (refCntUpdater.compareAndSet(this, refCnt, nextCnt)) { 
                    break;
                }
            }
            return this;
        }

参考

https://my.oschina.net/u/4072299/blog/3115164

### AtomicReferenceFieldUpdater ###

package com.dongguo.atomic;
    
    
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
    
    class MyVar { 
        public volatile Boolean isInit = Boolean.FALSE;
        AtomicReferenceFieldUpdater<MyVar, Boolean> atomicReferenceFieldUpdater = AtomicReferenceFieldUpdater.newUpdater(MyVar.class, Boolean.class, "isInit");
    
    
        public void init(MyVar myVar) { 
            if (atomicReferenceFieldUpdater.compareAndSet(myVar, Boolean.FALSE, Boolean.TRUE)) { 
                System.out.println(Thread.currentThread().getName() + "\t" + "---init.....");
                //暂停几秒钟线程
                try { 
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "\t" + "---init.....over");
            } else { 
                System.out.println(Thread.currentThread().getName() + "\t" + "------其它线程正在初始化");
            }
        }
    
    }
    /** * @author Dongguo * @date 2021/9/7 0007-14:55 * 多线程并发调用一个类的初始化方法，如果未被初始化过，将执行初始化工作，要求只能初始化一次 */
    public class AtomicReferenceFieldUpdaterDemo { 
        public static void main(String[] args) throws InterruptedException { 
            MyVar myVar = new MyVar();
    
            for (int i = 1; i <= 5; i++) { 
                new Thread(() -> { 
                    myVar.init(myVar);
                }, String.valueOf(i)).start();
            }
        }
    }
    运行结果
    1	---init.....
    2	------其它线程正在初始化
    3	------其它线程正在初始化
    4	------其它线程正在初始化
    5	------其它线程正在初始化
    1	---init.....over

**AtomicReferenceFieldUpdater**\+volatile的使用

## 原子操作增强类（原子累加器） ##

**DoubleAccumulator**

**DoubleAdder**

**LongAccumulator**

**LongAdder**

### 常用API ###

![image-20210907151408568][]

#### LongAdder只能用来计算加法，且从零开始计算 ####

package com.dongguo.atomic;
    
    import java.util.concurrent.atomic.LongAdder;
    
    /** * @author Dongguo * @date 2021/9/7 0007-15:17 * @description: */
    public class LongAdderAPIDemo { 
        public static void main(String[] args) { 
            LongAdder longAdder = new LongAdder();
            System.out.println(longAdder.longValue());
            longAdder.increment();
            longAdder.increment();
            longAdder.increment();
    
            System.out.println(longAdder.longValue());
        }
    }
    运行结果
    0
    3

#### LongAccumulator提供了自定义的函数操作 ####

package com.dongguo.atomic;
    
    import java.util.concurrent.atomic.LongAccumulator;
    
    /** * @author Dongguo * @date 2021/9/7 0007-15:27 * @description: 累加操作 */
    public class LongAccumulatorAPIDemo { 
        public static void main(String[] args) { 
            LongAccumulator accumulator = new LongAccumulator((x, y) -> { 
                return x + y;
            }, 0);
            accumulator.accumulate(1);
            accumulator.accumulate(2);
            accumulator.accumulate(3);
    
            System.out.println(accumulator.longValue());
        }
    }
    运行结果
    6

package com.dongguo.atomic;
    
    import java.util.concurrent.atomic.LongAccumulator;
    
    /** * @author Dongguo * @date 2021/9/7 0007-15:27 * @description: 累减操作 */
    public class LongAccumulatorAPIDemo { 
        public static void main(String[] args) { 
            LongAccumulator accumulator = new LongAccumulator((x, y) -> { 
                return x - y;
            }, 100);
            accumulator.accumulate(1);
            accumulator.accumulate(2);
            accumulator.accumulate(3);
    
            System.out.println(accumulator.longValue());
        }
    }
    运行结果
    94

### synchronized、atomicLong、LongAdder 与 LongAccumulator性能对比 ###

50个线程，每个线程100W次，算出总点赞数出来，对比性能。

package com.dongguo.atomic;
    
    import java.util.concurrent.CountDownLatch;
    import java.util.concurrent.atomic.AtomicInteger;
    import java.util.concurrent.atomic.AtomicLong;
    import java.util.concurrent.atomic.LongAccumulator;
    import java.util.concurrent.atomic.LongAdder;
    
    /** * @author Dongguo * @date 2021/9/7 0007-16:37 * @description: 50个线程，每个线程100W次，总点赞数 */
    class ClickNumber { 
        int number = 0;
    
        //使用synchronized
        public synchronized void add_Synchronized() { 
            number++;
        }
        //atomicInteger
        AtomicInteger atomicInteger = new AtomicInteger(0);
    
        public void add_atomicInteger() { 
            atomicInteger.incrementAndGet();
        }
    
        //atomicLong
        AtomicLong atomicLong = new AtomicLong(0);
    
        public void add_AtomicLong() { 
            atomicLong.decrementAndGet();
        }
    
        //longAdder
        LongAdder longAdder = new LongAdder();
    
        public void add_LongAdder() { 
            longAdder.increment();
        }
    
        //longAccumulator
        LongAccumulator longAccumulator = new LongAccumulator((x, y) -> x + y, 0);
    
        public void add_LongAccumulator() { 
            longAccumulator.accumulate(1);
        }
    }
    
    public class ClickNumberDemo { 
        public static void main(String[] args) throws InterruptedException { 
            ClickNumber clickNumber = new ClickNumber();
    
            long startTime;
            long endTime;
            CountDownLatch countDownLatch = new CountDownLatch(50);
            CountDownLatch countDownLatch2 = new CountDownLatch(50);
            CountDownLatch countDownLatch3 = new CountDownLatch(50);
            CountDownLatch countDownLatch4 = new CountDownLatch(50);
            CountDownLatch countDownLatch5 = new CountDownLatch(50);
    
            startTime = System.currentTimeMillis();
            for (int i = 1; i <=50; i++) { 
                new Thread(() -> { 
                    try
                    { 
                        for (int j = 1; j <=100 * 10000; j++) { 
                            clickNumber.add_Synchronized();
                        }
                    }finally { 
                        countDownLatch.countDown();
                    }
                },String.valueOf(i)).start();
            }
            countDownLatch.await();
            endTime = System.currentTimeMillis();
            System.out.println("----costTime: "+(endTime - startTime) +" 毫秒"+"\t add_Synchronized result: "+clickNumber.number);
    
    
            startTime = System.currentTimeMillis();
            for (int i = 1; i <=50; i++) { 
                new Thread(() -> { 
                    try
                    { 
                        for (int j = 1; j <=100 * 10000; j++) { 
                            clickNumber.add_AtomicLong();
                        }
                    }finally { 
                        countDownLatch2.countDown();
                    }
                },String.valueOf(i)).start();
            }
            countDownLatch2.await();
            endTime = System.currentTimeMillis();
            System.out.println("----costTime: "+(endTime - startTime) +" 毫秒"+"\t add_AtomicLong result: "+clickNumber.number);
    
    
            startTime = System.currentTimeMillis();
            for (int i = 1; i <=50; i++) { 
                new Thread(() -> { 
                    try
                    { 
                        for (int j = 1; j <=100 * 10000; j++) { 
                            clickNumber.add_atomicInteger();
                        }
                    }finally { 
                        countDownLatch5.countDown();
                    }
                },String.valueOf(i)).start();
            }
            countDownLatch5.await();
            endTime = System.currentTimeMillis();
            System.out.println("----costTime: "+(endTime - startTime) +" 毫秒"+"\t add_atomicInteger result: "+clickNumber.number);
    
    
            startTime = System.currentTimeMillis();
            for (int i = 1; i <=50; i++) { 
                new Thread(() -> { 
                    try
                    { 
                        for (int j = 1; j <=100 * 10000; j++) { 
                            clickNumber.add_LongAdder();
                        }
                    }finally { 
                        countDownLatch3.countDown();
                    }
                },String.valueOf(i)).start();
            }
            countDownLatch3.await();
            endTime = System.currentTimeMillis();
            System.out.println("----costTime: "+(endTime - startTime) +" 毫秒"+"\t add_LongAdder result: "+clickNumber.number);
    
            startTime = System.currentTimeMillis();
            for (int i = 1; i <=50; i++) { 
                new Thread(() -> { 
                    try
                    { 
                        for (int j = 1; j <=100 * 10000; j++) { 
                            clickNumber.add_LongAccumulator();
                        }
                    }finally { 
                        countDownLatch4.countDown();
                    }
                },String.valueOf(i)).start();
            }
            countDownLatch4.await();
            endTime = System.currentTimeMillis();
            System.out.println("----costTime: "+(endTime - startTime) +" 毫秒"+"\t add_LongAccumulator result: "+clickNumber.number);
    
        }
    }
    运行结果
    ----costTime: 1699 毫秒	 add_Synchronized result: 50000000
    ----costTime: 936 毫秒	 add_AtomicLong result: 50000000
    ----costTime: 1036 毫秒	 add_atomicInteger result: 50000000
    ----costTime: 175 毫秒	 add_LongAdder result: 50000000
    ----costTime: 203 毫秒	 add_LongAccumulator result: 50000000

可以看出大数据量场景LongAdder、LongAccumulator 性能要比AtomicLong快

那么下面这些场景就可以考虑LongAdder、LongAccumulator 的使用了。

*  1 抖音点赞计算器，点赞数加加统计，不要求实时精确
 *  2 一个很大的List，里面都是int类型，如何实现加加，

# AtomicLong与LongAdder总结 #

![image-20210907132620107][]

为什么阿里Java开发手册推荐使用LongAdder代替AtomicLong呢？看完这篇文章我相信你已经有所收获了。

## AtomicLong ##

### 原理 ###

CAS+自旋

incrementAndGet

### 场景 ###

低并发下的全局计算

AtomicLong能保证并发情况下计数的准确性，其内部通过CAS来解决并发安全性的问题。

### 缺陷 ###

高并发后性能急剧下降

AtomicLong的自旋会成为瓶颈

N个线程CAS操作修改线程的值，每次只有一个成功过，其它N - 1失败，失败的不停的自旋直到成功，这样大量失败自旋的情况，一下子cpu就打高了。

## LongAdder ##

### 原理 ###

CAS+Base+Cell数组分散

空间换时间并分散了热点数据

### 场景 ###

高并发下的全局计算

### 缺陷 ###

sum求和后还有计算线程修改结果的话，最后结果不够准确

[image-20210910091045867]: /images/20220828/f1c2b85620e94f1080843cd7ffd62c89.png
[d4ade015b68c2edbc4cb6b66b894f957.png]: /images/20220828/34bdbf3cc16f4c92aadcfe29c0c22a4c.png
[image-20210907151408568]: /images/20220828/8d32228b402f40f5ac1e360482d0c820.png
[image-20210907132620107]: /images/20220828/92893052de794d87b3c7f91d0352a94b.png