volatile 关键字 和 i++ 原子性

 package com.mozq.multithread;

 /**
  * 深入理解Java虚拟机 volatile 关键字 和 i++ 原子性。
  */
 public class VolatileTest {
     public static volatile int race = 0;

     private static final int THREADS_COUNT = 20;

     public static void main(String[] args) {
         Thread[] threads = new Thread[THREADS_COUNT];
         for(int i = 0; i < THREADS_COUNT; i++){
             threads[i] = new Thread(()-> {//自增 10000 次
                 for (int j = 0; j < 10000; j++) {
                     race++;
                 }
             });
             threads[i].start();
         }
         //等待所有线程执行完毕
         for(int i = 0; i < THREADS_COUNT; i++){
             try {
                 threads[i].join();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }

         System.out.println(race);
     }
     /*
     javap -v VolatileTest.class
     使用 javap 工具生成字节码指令信息，发现自增操作对应多条字节码指令，一条字节码至少对应一条机器指令，所以自增对应多条机器指令。
     更严谨的说法应该验证自增操作和汇编指令间的对应关系。可以使用 PrintAssembly 工具生成对应汇编指令。
     public static void increase();
     descriptor: ()V
     flags: ACC_PUBLIC, ACC_STATIC
     Code:
       stack=2, locals=0, args_size=0
          0: getstatic     #2                  // Field race:I
          3: iconst_1
          4: iadd
          5: putstatic     #2                  // Field race:I
     */
 }

 package com.mozq.multithread;

 import java.util.concurrent.BlockingQueue;
 import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.concurrent.locks.LockSupport;
 // CAS自定义锁及模拟高并发测试 https://blog.csdn.net/LiuRenyou/article/details/92996001#CountDownLatch_54
 public class ExclusiveLock {
     AtomicReference<Thread> sign = new AtomicReference();
     BlockingQueue<Thread> waiter = new LinkedBlockingQueue();

     public  void lock(){
         Thread thread = Thread.currentThread();
         while(!sign.compareAndSet(null,thread)){
             waiter.add(thread);
             //这里不可以用wait notify，因为notify不能唤醒指定的线程，只能用LockSupport
             LockSupport.park();
             waiter.remove(thread);
         }
     }

     public void unlock(){
         if(sign.compareAndSet(Thread.currentThread(),null)){
             Object[] arrs = waiter.toArray();
             for (Object obj:arrs) {
                 LockSupport.unpark((Thread)obj);
             }
         }
     }
 }