synchronized实现可见性

JMM关于synchronized的两条规定:

  1)线程解锁前,必须把共享变量的最新值刷新到主内存中

  2)线程加锁时,将清空工作内存中共享变量的值,从而使用共享变量时需要从主内存中重新获取最新的值

   (注意:加锁与解锁需要是同一把锁)

     通过以上两点,可以看到synchronized能够实现可见性。同时,由于synchronized具有同步锁,所以它也具有原子性

  

 多线程中程序交错执行时,重排序可能会造成内存可见性问题

 接下来我们看一段代码:

复制代码
/**
 * synchronized能够实现原子性(同步)、可见性
 * 
 * @author xuwenjin
 */
public class SynchronizedDemo {

    //共享变量
    private boolean ready = false;
    private int result = 0;
    private int number = 1;

    /**
     * 写操作
     */
    public void write() {
        ready = true; //1.1
        number = 2;   //1.2
    }

    /**
     * 读操作
     */
    public void read() {
        if (ready) {             //2.1
            result = number * 3; //2.2
        }
        System.out.println("result:" + result);
    }

    //内部线程类
    private class WriteReadThread extends Thread {
        
        private  boolean flag = false;
        
        public WriteReadThread(boolean flag){
            this.flag = flag;
        }
        
        @Override
        public void run() {
            if (flag) {
                write();
            }else {
                read();
            }
        }
    }
    
    public static void main(String[] args) {
        SynchronizedDemo demo = new SynchronizedDemo();
        //启动线程执行写操作
        demo.new WriteReadThread(true).start();
        //启动线程执行读操作
        demo.new WriteReadThread(false).start();
    }

}
复制代码

 上面的代码可能出现如下执行顺序:

  1) 1.1 --> 1.2 --> 2.1--> 2.2       result的值为6 (正常情况)

  2) 1.1 --> 2.1 --> 2.2 --> 1.2       result的值为3 (当写线程执行完1.1之后,读线程开始)

  3) 1.2 --> 2.1 --> 2.2 --> 1.1       result的值为0 (1.1跟1.2重排序)

  4)...

 当然由于重排序和线程的交叉执行,还可能出现很多种执行顺序

 导致共享变量在线程间不可见的原因:

  a、线程的异步执行

  b、重排序结合线程交叉执行

  c、共享变量更新后的值没有在工作内存与主内存间及时更新

 那么如何解决可见性的问题呢?接下来我们的主角出场:synchronized

 安全的代码:

复制代码
    /**
     * 写操作
     */
    public synchronized void write() {
        ready = true; //1.1
        number = 2;   //1.2
    }

    /**
     * 读操作
     */
    public synchronized void read() {
        if (ready) {             //2.1
            result = number * 3; //2.2
        }
        System.out.println("result:" + result);
    }
复制代码

由于synchronized的原子性、可见性,可以完美解决以上说的三点问题。不过读线程和写线程的执行顺序是不定的,所以result的结果仍然会出现6或0。

如何保证线程顺序执行,大家可参考:https://blog.csdn.net/wenxingchen/article/details/78026767

 

posted @   仅此而已-远方  阅读(11114)  评论(1编辑  收藏  举报
编辑推荐:
· .NET Core 对象分配(Alloc)底层原理浅谈
· 聊一聊 C#异步 任务延续的三种底层玩法
· 敏捷开发:如何高效开每日站会
· 为什么 .NET8线程池 容易引发线程饥饿
· golang自带的死锁检测并非银弹
阅读排行:
· 一个适用于 .NET 的开源整洁架构项目模板
· AI Editor 真的被惊到了
· API 风格选对了,文档写好了,项目就成功了一半!
· 【开源】C#上位机必备高效数据转换助手
· .NET 9.0 使用 Vulkan API 编写跨平台图形应用
点击右上角即可分享
微信分享提示