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);
            }
        }
    }
}