异同

volatile：重点在于告诉JVM被标记变量在线程的私有工作内存中的值是不确定的，每次都需要从主存中读取。
synchronized：对某一对象上锁，被保护的代码块无法并发执行。

二者都使用了内存屏障，保证“读之前”或“写之后”所有的CPU操作都同步刷新到主存中。

实验

该测试在windows10，JDK1.8.0_271下执行：

volatile的错误用法

首先测试 volatile标记的整型变量在两个线程下做累加操作：

public class Test {
    volatile static long a = 0;

    public static void main(String[] args) {
        Runnable r = () -> {
            for (int i = 0; i < 100_000_000; i++) {
                a++;
            }
        };
        Thread t1 = new Thread(r);
        Thread t2 = new Thread(r);

        long start = System.currentTimeMillis();
        t1.start();
        t2.start();
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long end = System.currentTimeMillis();
        System.out.println(a);
        System.out.println(end - start);
    }
}

volatile标记变量测试结果

因为volatile只能保证原子操作的原子性，a++实际上为复合操作，包括读取，相加，写入三部分，因此并没有得到正确的预期结果。两个线程交替进行a++操作，进行了大量的线程内存和主存的同步操作和数据拷贝，因此花费时间很长。

synchronized的正确用法

使用synchronized对当前类对象上锁测试累加结果：

public class Test {
    static long a = 0;

    public static void main(String[] args) {
        Runnable r = () -> {
            synchronized (Test.class) {
                for (int i = 0; i < 100_000_000; i++) {
                    a++;
                }
            }
        };
        Thread t1 = new Thread(r);
        Thread t2 = new Thread(r);

        long start = System.currentTimeMillis();
        t1.start();
        t2.start();
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long end = System.currentTimeMillis();
        System.out.println(a);
        System.out.println(end - start);
    }
}

synchronized保护代码块测试结果

可见synchronized获取了正确的实验结果且时间明显变短（因为同步操作只在synchronized加锁前后进行，且同一线程可能多次连续加锁成功，因此数据在线程工作内存和主存之间的拷贝次数明显减少，因而花费时间较短）。

volatile的正确用法

import java.util.concurrent.TimeUnit;

public class Test {
//    volatile static boolean a = true;
    static boolean a = true;

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            while (a) {}
        });
        Thread t2 = new Thread(() -> {
            a = false;
        });
        
        t1.start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t2.start();
    }
}

a未加volatile修饰，该程序在线程t2中修改了a的值，无法同步到线程t1的工作内存中，导致t1无法终止，程序无法结束。如果在a的前面加上volatile修饰，则可以将t2线程修改的值刷新到主存，同时t1能读取到值的修改，程序能正常结束。