1. import java.util.concurrent.atomic.AtomicInteger;
    2. import java.util.concurrent.atomic.AtomicLong;
    3. import java.util.concurrent.atomic.LongAdder;
    5. /**
    6.  * @version 1.0.0
    7.  * @Author Meir
    8.  * @copyright(C) 
    9.  */
    10. public class SynchronizedTest {
    12.     /**
    13.      * 性能 LongAdder > AtomicInteger > 直接加synchronized
    14.      */
    15.     public static void main(String[] args) throws InterruptedException {
    16.         At a = new At();
    17.         long l1 = System.currentTimeMillis();
    18.         Thread thread = new Thread(() -> {
    19.             for (int i = 0; i < 1000000; i++) {
    20.                 a.atomicIntegerIncrease();
    21.             }
    22.         });
    23.         thread.start();
    24.         for (int i = 0; i < 1000000; i++) {
    25.             a.atomicIntegerIncrease();
    26.         }
    27.         thread.join();
    28.         System.out.println(System.currentTimeMillis() - l1);
    29.         System.out.println(a.getNum(
    31.         ));
    32.     }
    34.     static class At {
    35.         int num = 0;
    36.         //1.原子操作integer
    37.         //内部实现-CAS 比较并交换
    38.         AtomicInteger atomicInteger = new AtomicInteger();
    40.         //2.
    41.         LongAdder longAdder = new LongAdder();
    44.         public int getNum() {
    45. //            return num;
    47.             return atomicInteger.get();
    49. //            return longAdder.longValue();
    50.         }
    51. //        不加锁不安全
    52.         public void increase() {
    53.             num ++;
    54.         }
    56.         /**
    57.          * synchronized锁的是同步代码块 this方法
    58.          */
    59.         public synchronized void synchronizedIncrease() {
    60.             num ++;
    61.             //效果一样     锁的是同步代码块 this方法
    62. //            synchronized (this) {
    63. //                num ++;
    64. //            }
    65.         }
    67.         /**
    68.          * AtomicInteger
    69.          */
    70.         public synchronized void atomicIntegerIncrease() {
    71.             atomicInteger.incrementAndGet();
    72.             //实现步骤 自旋比较    
    73.             //CAS机制中使用了3个基本操作数：内存地址V，旧的预期值A，要修改的新值B。
    74.              //更新一个变量的时候，只有当变量的预期值A和内存地址V当中的实际值相同时，才会将内存地址V对应的值修改为B。
    75. //            while (true) {
    76. //                int oldNum = atomicInteger.get();
    77. //                int newNum = oldNum + 1;
    78. //            //compareAndSet底层是一个原子操作 c++对他底层汇编的cmoxchgq（Compare exchange 比较交换）方法有加锁 （缓存行锁/总线锁）
    79. //                if (atomicInteger.compareAndSet(oldNum, newNum)) {
    80. //                    break;
    81. //                }
    82. //            }
    83.             //ABA问题 ：有线程在改值时 拿到旧值A 在+1生成B时另一线程如果速度更快 把旧值A改成C再改成A
    84.             //解决：加版本号version 每次操作版本+1 C改A版本就是3 1线程A改B就会发现版本不一致不修改
    85.             //例如类：AtomicStampedReference  compareAndSet方法加了stamp标记
    86.         }
    88.         /**
    89.          * LongAdder
    90.          */
    91.         public synchronized void LongAdderIncrease() {
    92.             //底层实现CAS分段优化机制 自动迁移机制
    93.             //当多个线程进行修改时，使用多个cell单元格，每个cell value初始值为0，分散多个线程的请求压力
    94.             //如果需要求和 则将base和所有的cell加起来即可
    96.             //当线程增多，每个cell中分配的线程数也会增多，当其中一个线程操作失败的时候
    97.             //它会自动迁移到下一个cell中进行操作，这也就解决了CAS空旋转，自旋不停等待的问题。这就是 自动迁移机制。
    98.             longAdder.increment();
    99.         }
    101.     }
    102. }