volatile关键字介绍及synchronized和volatile的区别

关于synchronized的解释请参考：https://blog.csdn.net/A798194701/article/details/123053501
首先volatile 只能用来修饰变量，当一个变量被它修饰后具备如下属性：

1. 禁止指令重排

   1. 什么是指令重排？指编译器或CPU为了优化程序的执行性能而对指令进行重新排序的一种手段，重排序会带来可见性问题，所以在多线程开发中必须要关注并规避重排序。即从源代码到指令序列的重排序。

   2. 从源代码到最终运行的指令，会经过如下两个阶段的重排序。

      第一阶段，编译器重排序，就是在编译过程中，编译器根据上下文分析对指令进行重排序，目的是减少CPU和内存的交互，重排序之后尽可能保证CPU从寄存器或缓存行中读取数据。

      第二阶段，处理器重排序，处理器重排序分为两个部分。

      • 并行指令集重排序，这是处理器优化的一种，处理器可以改变指令的执行顺序。
      • 内存系统重排序，这是处理器引入Store Buffer缓冲区延时写入产生的指令执行顺序不一致的问题

   int a = 0;
    boolean flag = false;
    public void method1() {
        a = 1;
        flag = true;
    }
    /* 
    	不禁止重排序多线程下会有如下情况发生：
        多线程下会交替执行，由于编译器优化，会发生指令重排，
        两个线程中使用的变量的一致性是无法确定的，结果无法预测，
        当flag=true先于a=1执行时，可能会输出"a的值为：5"
        当flag=true后于a=1执行时，输出"a的值为：6"
    */
    public void method2() {
        if (flag) {
            a += 5;
            System.out.println("a的值为：" + a);
        }
    }
   

此部分参考链接

2. 保证变量的可见性

   1. 由于 JVM运行程序的实体是线程，而每一个线程创建时JVM都会为其创建一个工作内存（有些地方称为栈空间），工作内存是每一个线程的私有数据区域，而 Java内存模型中规定所有变量都存储在主内存中，主内存是共享内存区域，所有线程都可以访问，但线程对变量的操作（读取赋值时）必须在工作内存中进行，首先要将变量从主内存拷贝到自己的工作内存空间，然后对变量进行操作，操作完成后再将变量写回主内存，不能直接操作主内存中的变量，各个线程中的工作内存中存储主内存变量的副本拷贝，因此不同线程间无法访问对方的工作内存，线程间的通信（传值）必须通过主内存来完成，其简要访问过程如下图：
      

   2. 当一个线程修改了变量值，其新值对其他线程可见。解决在多个线程之间变量不一致的问题

保证可见性的代码验证

class VolatileNumber{
    int number = 1;
    public void addOne(){
        this.number += 1;
    }
}
public class VolatileTest {
    public static void main(String[] args) {
        VolatileNumber volatileNumber = new VolatileNumber();
        new Thread(()->{
            System.out.println(Thread.currentThread().getName() + " come in");
            try {
                Thread.sleep(3000);
                volatileNumber.addOne();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+" update number");

        },"线程1").start();
		// 若值没发生改变，则一直循环
        while (volatileNumber.number == 1) {
        }
        System.out.println("main 线程执行结束。。。。");
    }
}

当我们不在变量上加上 volatile关键字时，输入内容如下：

线程1 come in
线程1 update numbe

加上 volatile关键字时，输入内容如下：

线程1 come in
线程1 update number
main 线程执行结束。。。。

volatile不能保证原子性的验证

class VolatileNumber{
     volatile int number = 0;
    public  void addOne() {
        this.number += 1;
    }
}
public class VolatileTest {

    public static void main(String[] args) {
        VolatileNumber volatileNumber = new VolatileNumber();
        for (int i = 1; i <= 20; i++) {
            new Thread(()->{
                for (int j = 1; j <= 1000; j++) {
                    volatileNumber.addOne();
                }
            },String.valueOf(i)).start();
        }
        // 为什么大于2？因为默认有两个线程，为main线程和GC线程
        while (Thread.activeCount() > 2) {
            Thread.yield(); // 做出线程让步
        }
        System.out.println("最终结果：" + volatileNumber.number);
    }
}

我们想要的值是20000，但经过运行，值总到不了20000。怎样才能保证原子性呢？

• 使用 synchronized修饰方法

• 使用 AtomicInteger声明变量

  class VolatileNumber{
       volatile int number = 0;
      public  void addOne() {
          this.number += 1;
      }
  	// 使用AtomicInteger声明的变量保证了变量的原子性
      AtomicInteger atomicInteger = new AtomicInteger();
      public void addAtomic(){
          atomicInteger.addAndGet(1);
      }
  
  }
  public class VolatileTest {
      public static void main(String[] args) {
          VolatileNumber volatileNumber = new VolatileNumber();
          for (int i = 1; i <= 20; i++) {
              new Thread(()->{
                  for (int j = 1; j <= 1000; j++) {
                      volatileNumber.addOne();
                      volatileNumber.addAtomic();
                  }
              },String.valueOf(i)).start();
          }
          // 为什么大于2？因为默认有两个线程，为main线程和GC线程
          while (Thread.activeCount() > 2) {
              Thread.yield(); // 做出线程让步
          }
          System.out.println("最终结果int：" + volatileNumber.number);
          System.out.println("最终结果atomic：" + volatileNumber.atomicInteger);
      }
  }
  
  

总结：

1. volatile只能作用于变量，而synchronized可以作用于方法和代码块
2. volatile只能保证变量的可见性，不能保证变量的原子性。synchronized既可以保证原子性又可以保证可见性
3. 在多线程中，volatile 主要用于解决变量在多线程中的可见性，保证看到的变量是相同的。synchronized主要用于解决多线程之间资源的同步问题，保证在同一时刻，只有一个线程对资源进行操作