jvm-synchronized和volatile

synchronized

进入、退出同步块时会刷新所有工作内存，使得其他线程对刚退出同步块的线程对共享变量所作的更新可见。通过锁机制，synchronized实现了原子性和有序性，即同一时刻只能有一个线程进入临界区，且保证了下一个线程进入临界区之前上一个线程已经退出临界区。

volatile

同样通过刷新工作内存，实现了可见性，通过禁止指令重排序实现了有序性（个人理解：首先禁止编译器对jvm指令编译成机器指令时的重排序，其次禁止cpu执行机器指令时的指令重排序）。

public class TestSynchronizedAndVolatile {
    private boolean b = false;
    private volatile Object lock = new Object();

    /**
     * 普通变量的写操作，不但会写入缓存，还会写回主内存
     */
    @Test
    public void test1() throws InterruptedException {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    /**
                     * 为了判断主线程中b=true是写入了主内存，还是仅写入工作内存。
                     * 之后的循环会跳出，说明了主线程中b=true回写到了主内存中。
                     */
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                }
                while (true) {
                    if (b) {
                        break;
                    }
                    b = false;
                }
                System.out.println("end");
            }
        }).start();
        b = true;
        Thread.sleep(1000);
    }
    /**
     * 线程中第一次读取到共享变量后，该变量会缓存在工作内存中，
     * 再次访问时直接从工作内存中读取，而不会重新从主内存中读取。
     * 这就造成了多线程访问共享变量时，访问到的是旧值。
     */
    @Test
    public void test2() throws InterruptedException {
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    /**
                     * 主线程中b=true后于子线程执行，虽然b=true已经作用于主内存，
                     * 但此前子线程已经将b读入工作内存（缓存），子线程没有动机再次从主线程同步b，
                     * 故这里会无限循环
                     */
                    if (b) {
                        break;
                    }
                }
                System.out.println("end");
            }
        }).start();
        Thread.sleep(100);
        b = true;
        Thread.sleep(100);
    }

    /**
     * synchronized会刷新缓存
     */
    @Test
    public void test3() throws InterruptedException {
        new Thread(new Runnable() {
            @Override
            public void run() {
                Object lock = new Object();
                while (true) {
                    /**
                     * 加入synchronized同步后情况发生了改变，当b=true同步回主内存后，
                     * 子线程中的b与主内存的值相同，循环跳出。
                     * 可见进入synchronized时会刷新工作内存（所有线程的工作内存），从而使得读取b时必须从主内存读取。
                     */
                    synchronized (lock) {
                        if (b) {
                            break;
                        }
                    }
                }
                System.out.println("end");
            }
        }).start();
        Thread.sleep(100);
        b = true;
        Thread.sleep(100);
    }

    /**
     * volatile会刷新缓存
     * @throws InterruptedException
     */
    @Test
    public void test4() throws InterruptedException {
        new Thread(new Runnable() {
            @Override
            public void run() {
                Object obj = null;
                while (true) {
                    /**
                     * 加入synchronized同步后情况发生了改变，当b=true同步回主内存后，
                     * 子线程中的b与主内存的值相同，循环跳出。
                     * 可见进入synchronized时会刷新工作内存（所有线程的工作内存），从而使得读取b时必须从主内存读取。
                     */
                    if (b) {
                        break;
                    }
                    System.out.println(b);
                    /**
                     * 由于lock是一个volatile，为了读到最新的lock值，这里就会刷新工作内存，
                     * 这样的话，当再次进入循环时，b就需要从主内存读取，所以可以跳出循环。
                     * （这里只体现了volatile可见性的语义，并没有体现禁止指令重排序的语义，
                     * 个人对指令重排序的理解分为两层，一层是编译器将jvm指令转换为机器指令时的重排序，
                     * 另一层是多核cpu并行执行指令造成的指令执行顺序的乱序。
                     * 而可见性则可以通过刷新所有线程的工作内存实现。）
                     */
                    obj = lock;
                    System.out.println("lock");
                }
                System.out.println("end");
            }
        }).start();
        Thread.sleep(10);
        b = true;
        Thread.sleep(100);
    }
}