关于synchronized 影响可见性的问题

问题来自于学习thinking in java的时候的一个示例，先上代码吧

public class StopThread {

    private static boolean stop = false;
    
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new Runnable(){
            public void run() {
                int i = 0;
                while (!stop) {
                    i++;
                }
            }
        });
        
        t.start();
        
        TimeUnit.SECONDS.sleep(1);
        stop = true;
    }
}

毫无疑问，这段代码会永远的执行下去，因为后台线程感觉不到主线程已经改变了stop，

然后我习惯性的在while循环中打印了下i(syso)

然后运行，发现程序在运行了一秒左右就停止了！！

我一脸懵逼，然后看了下syso的代码，发现有一段同步块

public void println(int x) {
        synchronized (this) {
            print(x);
            newLine();
        }
    }

然后我也在代码里尝试着加了一个空的同步块，发现也会停止

public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new Runnable(){
            @Override
            public void run() {
                int i = 0;
                
                Object lock = new Object();
                
                long start = System.nanoTime();
                while (!stop) {
                    i++;
                    
                    synchronized (lock) {
                        // nothing
                    }
                }
                
                long end = System.nanoTime();
                Duration d = Duration.ofNanos(end - start);
                System.out.println(d.toMillis() + "ms");
            }
        });
        
        t.start();
        
        TimeUnit.SECONDS.sleep(1);
        stop = true;
    }

运行结果是 1000ms

 

那么问题来了，synchronized 到底干了什么。。

按理说，synchronized 只会保证该同步块中的变量的可见性，发生变化后立即同步到主存，但是，stop变量并不在同步块中

实际上，JVM对于现代的机器做了最大程度的优化，也就是说，最大程度的保障了线程和主存之间的及时的同步，也就是相当于虚拟机尽可能的帮我们加了个volatile，但是，当CPU被一直占用的时候，同步就会出现不及时，也就出现了后台线程一直不结束的情况。

举个例子，在while循环中sleep一下，程序会很快的结束，sleep方法中并没有同步代码块

public void run() {
                int i = 0;
                long start = System.nanoTime();
                while (!stop) {
                    i++;
                    
                    try {
                        TimeUnit.MILLISECONDS.sleep(10);
                    } catch (InterruptedException e) {
                    }
                }
                
                long end = System.nanoTime();
                Duration d = Duration.ofNanos(end - start);
                System.out.println(d.toMillis() + "ms");
            }

再举个栗子，在while循环中做一些耗时但不耗CPU的操作，也会结束的很快，因为这个时候CPU空闲了，JVM就有机会尽快的将主存和栈变量同步

public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new Runnable(){
            @Override
            public void run() {
                int i = 0;
                long start = System.nanoTime();
                while (!stop) {
                    i++;
                     Object[] arr = new Object[1000000];
                }
                
                long end = System.nanoTime();
                Duration d = Duration.ofNanos(end - start);
                System.out.println(d.toMillis() + "ms");
            }
        });
        
        t.start();
        
        TimeUnit.SECONDS.sleep(1);
        stop = true;
    }