volatile和synchronized比较

Love The Way You Lie 2022-12-21 13:55 145阅读 0赞

面试时很可能遇到这样一个问题：**使用volatile修饰int型变量i，多个线程同时进行i++操作，这样可以实现线程安全吗**？提到线程安全、线程同步，我们经常会想到两个关键字：volatile和synchronized，那么这两者有什么区别呢？

## 1.volatile修饰的变量具有可见性 ##

**volatile是变量修饰符，其修饰的变量具有可见性。**  
可见性也就是说一旦某个线程修改了该被volatile修饰的变量，它会**保证修改的值会立即被更新到主存，当有其他线程需要读取时，可以立即获取修改之后的值**。  
在Java中为了加快程序的运行效率，对一些变量的操作通常是在该线程的寄存器或是CPU缓存上进行的，之后才会同步到主存中，而**加了volatile修饰符的变量则是直接读写主存。**

volatile的使用举例

class MyThread extends Thread {            
        private volatile boolean isStop = false;        
        public void run() {     
            while (!isStop) {     
                System.out.println("do something");    
            }    
        }    
        public void setStop() {     
            isStop = true;    
        }          
    }

线程执行run()的时候我们需要在线程中不停的做一些事情，比如while循环，那么这时候该如何停止线程呢？如果线程做的事情不是耗时的，那么只需要使用一个标志即可。如果需要退出时，调用setStop()即可。这里就使用了关键字volatile，这个关键字的**目的是如果修改了isStop的值，那么在while循环中可以立即读取到修改后的值。**

如果线程做的事情是耗时的，那么可以使用interrupt方法终止线程 。如果在子线程“睡觉”时被interrupt，那么子线程可以catch到InterruptExpection异常，处理异常后继续往下执行。

## 2.volatile禁止指令重排 ##

**volatile可以禁止进行指令重排。**

**指令重排是指处理器为了提高程序运行效率**，可能会对输入代码进行优化，它不保证各个语句的执行顺序同代码中的顺序一致，但是它会保证程序最终执行结果和代码顺序执行的结果是一致的。**指令重排序不会影响单个线程的执行，但是会影响到线程并发执行的正确性。**

程序执行到volatile修饰变量的读操作或者写操作时，在其前面的操作肯定已经完成，且结果已经对后面的操作可见，在其后面的操作肯定还没有进行。

//线程1:
    context = loadContext();   //语句1 context初始化操作
    inited = true;             //语句2
     
    //线程2:
    while(!inited ){ 
      sleep()
    }
    doSomethingwithconfig(context);

因为指令重排序，有可能语句2会在语句1之前执行，可能导致context还没被初始化，而线程2中就使用未初始化的context去进行操作，导致程序出错。

**这里如果用volatile关键字对inited变量进行修饰，就不会出现这种问题了。**

## 3.synchronized ##

**synchronized可作用于一段代码或方法，既可以保证可见性，又能够保证原子性。**

可见性体现在：通过synchronized或者Lock能保证**同一时刻只有一个线程获取锁然后执行同步代码，并且在释放锁之前会将对变量的修改刷新到主存中**。

**原子性**即：**要么不执行，要么执行到底。**

public class Test { 
        public volatile int inc = 0;
        public void increase() { 
            inc++;
        }
         
        public static void main(String[] args) { 
            final Test test = new Test();
            for(int i=0;i<10;i++){ 
                new Thread(){ 
                    public void run() { 
                        for(int j=0;j<1000;j++)
                            test.increase();
                    };
                }.start();
            }
             
            if(Thread.activeCount()>1)  //保证前面的线程都执行完
                Thread.yield();
            System.out.println(test.inc);
        }
    }

例子中用new了10个线程，分别去调用1000次increase()方法，每次运行结果都不一致，都是一个小于10000的数字。**自增操作不是原子操作，volatile 是不能保证原子性的**。

回到文章一开始的例子，使用volatile修饰int型变量i，多个线程同时进行i++操作。比如有两个线程A和B对volatile修饰的i进行i++操作，i的初始值是0，A线程执行i++时刚读取了i的值0，就切换到B线程了，B线程（从内存中）读取i的值也为0，然后就切换到A线程继续执行i++操作，完成后i就为1了，接着切换到B线程，因为之前已经读取过了，所以继续执行i++操作，最后的结果i就为1了。**同理可以解释为什么每次运行结果都是小于10000的数字**。

**但是使用synchronized对部分代码进行如下修改，就能保证同一时刻只有一个线程获取锁然后执行同步代码。运行结果必然是10000。**

public  int inc = 0;
    public synchronized void increase() { 
            inc++;
    }

## 4.总结 ##

通过使用volatile发现，虽然volatile可以解决内存可见性问题和指令重排序问题，但是volatile可能产生jvm代码的优化问题，效率可能降低。

那么我们什么时候使用volatile，我个人建议可能存在多个线程访问成员变量时，对变量的写入操作不依赖变量的当前值，如count++就不能用volatile修饰。

(1)**从而我们可以看出volatile虽然具有可见性但是并不能保证原子性。**  
(2)**volatile是比较弱的同步机制，在访问volatile变量时，不会进行加锁，也不会阻塞线程。**  
(3)**性能方面，synchronized关键字是防止多个线程同时执行一段代码，就会影响程序执行效率，而volatile关键字在某些情况下性能要优于synchronized。**

但是要注意volatile关键字是无法替代synchronized关键字的，因为**volatile关键字无法保证操作的原子性。**

**原文链接**  
https://blog.csdn.net/seu\_calvin/article/details/52370068