目录

定义：

解决方法：

①使用synchronized实现缓存和内存的同步

修改一：

加入语句：

代码：

修改2：

在代码块中加入：

代码：

执行结果：

原因：

②使用volatile实现变量可见性 

---

定义：

当多个线程访问同一个变量的时候，一个线程修改了这个变量的值，其他线程肯呢个看不到立即修改的值，他们之间存在着不可见的问题

导致这个的问题在于，多核cpu的多个核之间他们的高速缓存并不会共享，而各自运算的无数据肯呢个存在各自的高速缓存中

解决方法：

①使用synchronized实现缓存和内存的同步

public class Test1 {
    public  static Boolean always = true;
    public static void main(String[] args) {
       //子线程
        new Thread(()->{
           while (always){//主线程中修改了always的值，在子线程中没看到
             
           }

       }).start();
        try {
            Thread.sleep(2000);//主线程
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        always=false;

    }
}

执行结果：程序一直运行，不结束，主线程中修改了always的值，在子线程中没看到

修改一：

加入语句：

 synchronized (always){}

代码：

public class Test1 {
    public  static Boolean always = true;
    public static void main(String[] args) {
       //子线程
        new Thread(()->{
           while (always){
             
              synchronized (always){}
           }

       }).start();
        try {
            Thread.sleep(2000);//主线程
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        always=false;

    }
}

执行结果：运行两秒钟结束

原因是，同步了always语句修改的结果

修改2：

在代码块中加入：

System.out.println("hello");

代码：

public class Test1 {
    public  static Boolean always = true;
    public static void main(String[] args) {
       //子线程
        new Thread(()->{
           while (always){
             
               System.out.println("hello");
           }

       }).start();
        try {
            Thread.sleep(2000);//主线程
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        always=false;

    }
}

执行结果：

打印两秒钟hello，结束 

原因：

println函数中包含了sychronized,解决了可见性问题 

②使用volatile实现变量可见性 

定义变量的时候使用volatile

 public volatile static Boolean always = true;

代码：

public class Test1 {
    public volatile static Boolean always = true;
    public static void main(String[] args) {
       //子线程
        new Thread(()->{
           while (always){

                      }

       }).start();
        try {
            Thread.sleep(2000);//主线程
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        always=false;

    }
}

 执行结果：执行两秒