（一）JUC认知（内存可见性问题）

看到公司中的代码，我对于多线程的理解，仅限在实现Runnable和继承Thread，重写他们的run方法。最近才看到JUC–高级线程的学习。
首先呢，对于共享的资源的时候，如果有多条线程访问的时候，就有可能出现以下问题：

public class TestVolatile {
 
 public static void main(String[] args) {
  //ThreadDemo线程先开始的
       ThreadDemo td =new ThreadDemo();       
        new Thread(td).start();
        //然后这里是主线程才开始
       while(true) {
  
         if(td.isFlag()) {
             System.out.println("==============");
             break;
            }
  
        
       }
         
      
 }
}
class ThreadDemo implements Runnable{
    private boolean flag =false;
 public boolean isFlag() {
  return flag;
 }
 public void setFlag(boolean flag) {
  this.flag = flag;
 }
 @Override
 public void run() {
  // TODO Auto-generated method stub
  try {
   Thread.sleep(2000);
   flag =true;
   System.out.println("测试flag"+isFlag());
  } catch (InterruptedException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
 }
}

这是就是可以加一个锁来防止主线程读取之前，让ThreadDemo先读取然后写到内存中，才让主内存读取

public class TestVolatile {
 
 public static void main(String[] args) {
  //ThreadDemo线程先开始的
       ThreadDemo td =new ThreadDemo();       
        new Thread(td).start();
        //然后这里是主线程才开始
       while(true) {
        synchronized(td) {//使用锁来使他重复去读取，解决内存可见性的问题，但是加锁效率低
         if(td.isFlag()) {
             System.out.println("==============");
             break;
            }
        }
        
       }
         
      
 }
}
class ThreadDemo implements Runnable{
    private  boolean flag =false;//直接修飾就行
 public boolean isFlag() {
  return flag;
 }
 public void setFlag(boolean flag) {
  this.flag = flag;
 }
 @Override
 public void run() {
  // TODO Auto-generated method stub
  try {
   Thread.sleep(2000);
   flag =true;
   System.out.println("测试flag"+isFlag());
  } catch (InterruptedException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
 }
}

但是这个有一个问题就是效率问题，如果加锁的话，效率就比较低了，而且在代码量很大的时候，项目会给人一种很卡的体验，也就是说加锁是重量级的应用。
/**

• 关键字–volatile ：当多个线程进行 访问共享数据时内存时可见的，使用的时内存栅栏，时时刻刻将线程的缓存刷的主内存中
• 理解：就是线程时时刻刻都在操作主存中的数据

• 相較于synchronized 比較輕量級的應用（理解：synchronized就是锁，而volatile类似就是通行证，可以随时让线程修改的通行证）
  

• 注意：
• 1.volatile不具备互斥性（synchronized具备互斥性）
• 2.不能保证变量的原子性（不能分割）
• 问题一，内存可见性问题，当多个线程操作共享数据时，彼此不可见
• JVM中对于线程来说自己的线程有缓存，用来缓存读取主要内存中的数据，那么双方来说两个线程的内存肯定不是
• 对外可见的，就会发生以下的问题—只有ThreadDemo线程打印了，主线程中的while 一直都是死循环，说明while线程一直
• 都没有读取到flag 为true ，一直都是flase，但是ThreadDemo线程已经修改了，并且输出，while的效率高，所以一直都是
• 不读取主内存的
• ThreadDemo线程：这个线程先开始读取主内存中的flag为false ，然后修改主内存的flag 为ture，并输出
• main线程：再threadDemo读取后，但是ThreadDemo要睡眠2000，所以读取到的是false

*/

public class TestVolatile {
 
 public static void main(String[] args) {
  //ThreadDemo线程先开始的
       ThreadDemo td =new ThreadDemo();       
        new Thread(td).start();
        //然后这里是主线程才开始
       while(true) {
     //使用锁来使他重复去读取，解决内存可见性的问题，但是加锁效率低
         if(td.isFlag()) {
             System.out.println("==============");
             break;
            }
        
        
       }
         
      
 }
}
class ThreadDemo implements Runnable{
    private volatile boolean flag =false;//直接修飾就行
 public boolean isFlag() {
  return flag;
 }
 public void setFlag(boolean flag) {
  this.flag = flag;
 }
 @Override
 public void run() {
  // TODO Auto-generated method stub
  try {
   Thread.sleep(2000);
   flag =true;
   System.out.println("测试flag"+isFlag());
  } catch (InterruptedException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
 }
}