【Java】synchronized和volatile的比较

最新推荐文章于 2022-04-09 10:09:06 发布

77ISYJOJO

最新推荐文章于 2022-04-09 10:09:06 发布

阅读量167

点赞数

分类专栏：大数据学习笔记

本文链接：https://blog.youkuaiyun.com/weixin_43837588/article/details/89058231

版权

大数据学习笔记专栏收录该内容

16 篇文章

订阅专栏

本文详细解析了Java并发编程中volatile和synchronized两个关键字的作用与区别。通过具体案例分析了volatile如何解决线程间的变量可见性问题，以及synchronized如何提供更高级别的线程安全性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1. volatile

JMM内存模型抽象示意图：
在这里插入图片描述
从图中可以看出：
①每个线程都有一个自己的本地内存空间——线程栈空间。线程执行时，先把变量从主内存读取到线程自己的本地内存空间，然后再对该变量进行操作
②对该变量操作完后，在某个时间再把变量刷新回主内存

public class RunThread extends Thread {

    private boolean isRunning = true;

    public boolean isRunning() {
        return isRunning;
    }

    public void setRunning(boolean isRunning) {
        this.isRunning = isRunning;
    }

    @Override
    public void run() {
        System.out.println("进入到run方法中了");
        while (isRunning == true) {
        }
        System.out.println("线程执行完成了");
    }
}

public class Run {
    public static void main(String[] args) {
        try {
            RunThread thread = new RunThread();
            thread.start();
            Thread.sleep(1000);
            thread.setRunning(false);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Run.java 第28行，main线程将启动的线程RunThread中的共享变量设置为false，从而想让RunThread.java 第14行中的while循环结束。
如果，我们使用JVM -server参数执行该程序时，RunThread线程并不会终止！从而出现了死循环！！

原因分析：
现在有两个线程，一个是main线程，另一个是RunThread。它们都试图修改第三行的 isRunning变量。按照JVM内存模型，main线程将isRunning读取到本地线程内存空间，修改后，再刷新回主内存。

而在JVM 设置成 -server模式运行程序时，线程会一直在私有堆栈中读取isRunning变量。因此，RunThread线程无法读到main线程改变的isRunning变量
从而出现了死循环，导致RunThread无法终止。这种情形，在《Effective JAVA》中，将之称为“活性失败”

解决方法，在第三行代码处用 volatile 关键字修饰即可。这里，它强制线程从主内存中取 volatile修饰的变量。
volatile private boolean isRunning = true;

扩展一下，当多个线程之间需要根据某个条件确定哪个线程可以执行时，要确保这个条件在线程之间是可见的。因此，可以用volatile修饰。
综上，volatile关键字的作用是：使变量在多个线程间可见（可见性）

2. synchronized

与volatile的区别：

volatile轻量级，只能修饰变量。synchronized重量级，还可修饰方法。
volatile只能保证数据的可见性，不能用来同步，因为多个线程并发访问volatile修饰的变量不会阻塞。
synchronized不仅保证可见性，而且还保证原子性，因为，只有获得了锁的线程才能进入临界区，从而保证临界区中的所有语句都全部执行。多个线程争抢synchronized锁对象时，会出现阻塞。
所以，从线程安全性的角度看，仅仅使用volatile不能保证线程安全，而synchronized则可以实现线程安全性。

为什么synchronized是重量级的呢？
因为synchronized还可以修饰方法：

public class MyObject {

    private String userName = "b";
    private String passWord = "bb";
    
    synchronized public void methodA(String userName, String passWord) {
        this.userName = userName;
        try{
            Thread.sleep(5000);
        }catch(InterruptedException e){
            
        }
        this.passWord = passWord;
    }

    synchronized public void methodB() {
        System.out.println("userName" + userName + ": " + "passWord" + passWord);
    }
}

这里，synchronized 关键字锁住的是当前对象。这也是称为对象锁的原因。
为啥锁住当前对象？因为 methodA()是个实例方法，要想执行methodA()，需要以对象.方法() 的形式进行调用(obj.methodA()，obj是MyObject类的一个对象，synchronized就是把obj这个对象加锁了)。

methodA()负责更改用户名和密码。在现实中，一个用户名对应着一个密码。。。
methodB()负责读取用户名和密码。
如果methodB()没有用synchronized 修饰，线程A在调用methodA()执行到第7行，更改了用户名，因某种原因（比如在第9行睡眠了）放弃了CPU。
此时，如果线程B去执行methodB()，那么读取到的用户名是线程A更改了的用户名(“a”)，但是密码却是原来的密码(“bb”)。因为，线程A睡眠了，还没有来得及更改密码。
但是，如果methodB()用synchronized修饰，那么线程B只能等待线程A执行完毕之后（即改了用户名，也改了密码），才能执行methodB读取用户名和密码。因此，就避免了数据的不一致性而导致的脏读问题。

参考资料：http://www.cnblogs.com/hapjin/p/5452663.html