volatile的个人理解

package com.example.demo;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;

//测试volatile基于cas实现atomicInteger,
//解决num++复合计操作问题
public class VolitileTest {
    static AtomicInteger num = new AtomicInteger(0);
    //使用CountDownLatch来等待计算线程执行完
    static CountDownLatch countDownLatch = new CountDownLatch(30);

    public static void main(String[] args) {
        for (int i = 0; i < 30; i++) {
            new Thread(() -> {
                for (int j = 0 ; j< 10 ; j++){
                    num.getAndIncrement();
                }
                countDownLatch.countDown();
            }).start();
        }
        try {
            //计数结束后唤醒当前线程
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(num);

    }
}

//验证volatile 在保证原子性的情况实现共享变量可见性
class  b{
    static volatile boolean flag = false;

    public static void main(String[] args) {

        for (int i = 0 ; i < 10 ; i++){
            new Thread(()->{
                if(flag == true){
                    System.out.println(Thread.currentThread().getName() + "run");
                }else{
                    System.out.println(Thread.currentThread().getName() + "false");
                }
            }).start();
        }
        new Thread(()->{
            flag = true;
        }).start();
    }
}
//volatile 禁止指令重排
//指令重排意思是相互依赖的操作在单线程情况无论指令怎样重排都必须保证正确性
//禁止指令重排，是指在特定的共享变量上插入内存屏障禁止处理器指令重排

/**
 * 　volatile禁止指令重排序也有一些规则，简单列举一下：

 　　1.当第二个操作是voaltile写时，无论第一个操作是什么，都不能进行重排序

 　　2.当地一个操作是volatile读时，不管第二个操作是什么，都不能进行重排序

 　　3.当第一个操作是volatile写时，第二个操作是volatile读时，不能进行重排序
 */
class c{

}