synchronized 和 volatile 的区别是什么？

synchronized和volatile的使用方法以及区别

Java中volatile修饰符是一种用来保证不同线程之间交互的特殊机制。当一个线程修改volatile变量，另一个线程能够看到这个修改。第一个线程通知第二个线程变量已经被修改。

下面用图来解释：

ready是一个volatile boolean变量， 初值设为false. answer是一个非volatile int变量，初值是0.

第一个线程准备好修改ready变量，它是两个线程交流的发送方。第二个线程读取ready变量，获取第一个线程修改的值，因此它是接收方。在两个线程交流时，在线程1修改ready变量前，内存中所有变量对线程1可见，在线程2准备好读取ready变量的值true后，内存中所有变量必须对线程2可见。

这就保证了如果线程要输出什么的值的话，那就是42.

如果ready不是volatile的，那会发生什么呢？在线程1和线程2之间将不会有任何明显的交流。

线程1修改ready(现在是non-volatile)后的值可能会传递给线程2，因此线程可能可以读取ready的值true. 然而，线程1也可能不会将修改后的ready的值传递给线程2，answer的值也不会传递给线程2，那么线程2将会输出0.

区别先看下面的例子:

public class ThreadTest {

    public static void main(String[] args) {
        final Counter counter = new Counter();
        for (int i = 0; i < 1000; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    counter.inc();
                }
            }).start();
        }
        System.out.println(counter);
    }
}

public class Counter {

    private volatile int count = 0;

    public void inc() {
        try {
            Thread.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        count++;
    }
       @Override
    public String toString() {
        return "[count=" + count + "]";
    }
}

上面的例子是使用了volatile关键字修饰一个count变量，运行程序，结果会是神马？

结果不会是1000，或者说不等于1000.

下面是程序运行了3次的结果：

[count=971]

[count=968]

[count=972]

可以看出，程序运行的结果是不确定的，这说明了count++并不是原子级别的操作。

原因是声明为volatile的变量若与自身相关，如以下的声明方式：n=n+1,n++等，那么声明为volatile的变量就不起作用，也就是说关键字volatile无效。

分析：

在 java 的内存模型中每一个线程运行时都有一个线程栈，线程栈保存了线程运行时候变量值信息。当线程访问
某一个对象时候值的时候，首先通过对象的引用找到对应在堆内存的变量的值，然后把堆内存变量的具体值load到线
程本地内存中，建立一个变量副本，之后线程就不再和对象在堆内存变量值有任何关系，而是直接修改副本变量的值，
在修改完之后的某一个时刻（线程退出之前），自动把线程变量副本的值回写到对象在堆中变量。这样在堆中的对象
的值就产生变化了。
也就是说上面主函数中开启了1000 个子线程，每个线程都有一个变量副本，每个线程修改变量只是临时修改了
自己的副本，当线程结束时再将修改的值写入在主内存中，这样就出现了线程安全问题。因此结果就不可能等于1000
了，一般都会小于1000。

若想将count的操作变为原子级别，可以使用关键字synchronized，即可将类Counter修改为：

public class Counter {

    public static int count = 0;

    public synchronized void inc() {
        count++;
    }

    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                inc();// n=count+1改成了inc()
                Thread.sleep(3);// 为了使运行结果更随即，延迟3毫秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    public String toString() {
        return "[count=" + count + "]";
    }
}

程序运行3次的结果：

[count=1000]

[count=1000]

[count=1000]

synchronized和volatile的区别：

一旦一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义：
1）保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是
    立即可见的。
2）禁止进行指令重排序。
   volatile本质是在告诉jvm当前变量在寄存器（工作内存）中的值是不确定的，需要从主存中读取；
   synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。
1.volatile仅能使用在变量级别；
   synchronized则可以使用在变量、方法、和类级别的
2.volatile仅能实现变量的修改可见性，并不能保证原子性；

   synchronized则可以保证变量的修改可见性和原子性
3.volatile不会造成线程的阻塞；
   synchronized可能会造成线程的阻塞。
4.volatile标记的变量不会被编译器优化；
   synchronized标记的变量可以被编译器优化