共享变量在线程间的可见性

最新推荐文章于 2023-11-23 23:34:31 发布
最新推荐文章于 2023-11-23 23:34:31 发布
阅读量714 收藏 4
点赞数 1
分类专栏： 多线程

https://blog.csdn.net/osunxu/article/details/78443307

一共享变量在线程间的可见性

        (1)有关可见性的一些概念介绍

        可见性：一个线程对共享变量值的修改，能够及实地被其他线程看到。

        共享变量：如果一个变量在多个线程的工作内存中都存在副本，那么这个变量就是这几个线程的共享变量。所

有的变量都存储在主内存中。

        线程的工作内存：每个线程都有自己独立的工作内存，里面保存该线程使用到的变量的副本(主内存中该变量的

一份拷贝)。

        (2)数据争用问题

        多个线程对同一资源操作时，通常会产生进程，比如一个线程往消息队列插入数据，而另一个线程从消息队列取

出数据　当消息队列满时，插入消息的队列需要Sleep几个毫秒，把时间片让出给取消息的线程，当消息队列为空

时，取消息队列的线程需要Sleep几个毫秒，把时间片让给插入消息的线程。如果不这样做，则会出现某个线程独占

资源，最终导致另一个线程死等状态，会引发一些我问题。这其中就涉及到了数据争用问题。

        (3)Java内存模型(JMM)

        Java内存模型(Java Memory Model)描述了Java程序中各种变量(线程共享变量)的大访问规则，以及在JVM中将

变量存储到内存和从内存中读取变量这样的底层细节。

        JMM模型的工作流程：

        其中有两条规定：

        1)线程对共享变量的所有操作都必须在自己的工作内存中进行，不能直接从主存中读写。

        2)不同线程之间无法直接访问其他线程工作内存中的变量，线程间变量值的传递需要通过主存来完成。

        (4)共享变量可见性实现的原理

        线程1对共享变量的修改要想被线程2及时看到，必须要经过如下两个步骤：

        1)把工作内存1中更新过的共享变量刷新到主内存中。

        2)将主内存中最新的共享变量的值更新到工作内存2中。

        我们来看一下这个流程：

        要实现共享变量的的可见性，必须保证两点：

        1)线程修改后的共享变量值能够及时从工作内存刷新到主内存中。

        2)其他线程能够及时把共享变量的最新值从主内存更新到自己的工作内存中。

        (5)可见性的实现方式

        语言层面支持的可见性实现方式：

        1)使用关键字synchronized

        2)使用关键字volatile

        二synchronized实现可见性

        (1)Synchronized实现可见性

        Synchronized能够实现多线程的原子性(同步)和可见性。

        JVM关于Synchronized的两条规定：

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

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

意：加锁和解锁需要同一把锁)。

        (2)线程执行互斥代码的过程：

        1)获得互斥锁

        2)清空工作内存

        3)从主内存拷贝变量的最新副本到工作内存

        4)执行代码

        5)将更改后的共享变量的值刷新到主内存

        6)释放互斥锁

        (3)指令重排序

        重排序：代码书写的顺序与实际执行的顺序不同，指令重排序是编译器或处理器为了提高程序性能而做的优化。

        包括三种：

        1)编译器优化的重排序(编译器优化)

        2)指令级并行的重排序(处理器优化)

        3)内存系统的重排序(处理器优化)

        重排序的可能：

        (4)as-if-serial语义

        as-if-serial含义指的是无论如何重排序，程序执行的结果应该与代码顺序执行的结果一致(Java编译器、运行时和

处理器都会保证Java在单线程下遵循as-if-serial语义)。重排序不会给单线程带来内存可见性的问题。

        我们来看一段程序的例子：

 

        单线程中程序中第1、2行的顺序可以重排，但第3行不能。

 

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

        (5)synchronized实现可见性的实例代码：

 

[java] view plain copy

  1. public class SynchronizedDemo {  
  2.     //共享变量  
  3.     private boolean ready = false;  
  4.     private int result = 0;  
  5.     private int number = 1;     
  6.       
  7.     //写操作  
  8.     public void write(){  
  9.         ready = true;                   //1.1                 
  10.         number = 2;                     //1.2                 
  11.     }  
  12.       
  13.     //读操作  
  14.     public void read(){                
  15.         if(ready){              //2.1  
  16.             result = number*3;      //2.2  
  17.         }         
  18.         System.out.println(”result的值为：” + result);  
  19.     }  
  20.   
  21.   
  22.     //内部线程类  
  23.     private class ReadWriteThread extends Thread {  
  24.         //根据构造方法中传入的flag参数，确定线程执行读操作还是写操作  
  25.         private boolean flag;  
  26.           
  27.         public ReadWriteThread(boolean flag){  
  28.             this.flag = flag;  
  29.         }  
  30.                                                                               
  31.         public void run() {  
  32.             if(flag){  
  33.                 //构造方法中传入true，执行写操作  
  34.                 write();  
  35.             }else{  
  36.                 //构造方法中传入false，执行读操作  
  37.                 read();  
  38.             }  
  39.         }  
  40.     }  
  41.   
  42.   
  43.     public static void main(String[] args){  
  44.         SynchronizedDemo synDemo = new SynchronizedDemo();  
  45.         //启动线程执行写操作  
  46.                 synDemo.new ReadWriteThread(true).start();  
  47.         //启动线程执行读操作  
  48.         synDemo.new ReadWriteThread(false).start();  
  49.     }  
  50. }  
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 ReadWriteThread extends Thread {
        //根据构造方法中传入的flag参数，确定线程执行读操作还是写操作
        private boolean flag;

        public ReadWriteThread(boolean flag){
            this.flag = flag;
        }

        public void run() {
            if(flag){
                //构造方法中传入true，执行写操作
                write();
            }else{
                //构造方法中传入false，执行读操作
                read();
            }
        }
    }


    public static void main(String[] args){
        SynchronizedDemo synDemo = new SynchronizedDemo();
        //启动线程执行写操作
                synDemo.new ReadWriteThread(true).start();
        //启动线程执行读操作
        synDemo.new ReadWriteThread(false).start();
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49

 

        运行结果：

        在主线程中启动线程执行读、写操作。可见性分析：

        如果线程程序正常执行那么结果为：6

        第一种可能的执行顺序：

        1.1—>2.1—>2.2—>1.2

        result的值：3

        第二种可能的执行顺序：

        1.2—>2.1—>2.2—>1.1

        result的值：0

        也可能有其他的情况，就不再进行举例。导致共享变量在线程间不可见的原因：

        1)线程的交叉执行。

        2)重排序结合线程交叉执行。

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

        我们加入synchronized(this)同步代码块，当一个线程访问object的一个synchronized(this)同步代码块时，其他线

程对object中所有其它synchronized(this)同步代码块的访问将会被阻塞。

        实现可见性改写后的代码：

       可以在写线程和读线程之间加个休眠操作，让写线程执行完，读线程在执行，也可以使用wait和notify来控制线程

执行的顺序。

 

[java] view plain copy

  1. public static void main(String[] args){  
  2.         SynchronizedDemo synDemo = new SynchronizedDemo();  
  3.         //启动线程执行写操作  
  4.         synDemo.new ReadWriteThread(true).start();  
  5.         try {  
  6.             Thread.sleep(1000);  
  7.     } catch (InterruptedException e) {  
  8.             e.printStackTrace();  
  9.     }  
  10.         //启动线程执行读操作  
  11.         synDemo.new ReadWriteThread(false).start();  
  12. }  
public static void main(String[] args){
        SynchronizedDemo synDemo = new SynchronizedDemo();
        //启动线程执行写操作
        synDemo.new ReadWriteThread(true).start();
        try {
            Thread.sleep(1000);
    } catch (InterruptedException e) {
            e.printStackTrace();
    }
        //启动线程执行读操作
        synDemo.new ReadWriteThread(false).start();
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

 

        或者给读操作和写操作的方法声明中加关键字synchronized修饰：

 

[java] view plain copy

  1. //写操作  
  2.     public synchronized void write(){  
  3.         ready = true;                        //1.1                
  4.         number = 2;                         //1.2                 
  5.     }  
  6.       
  7.     //读操作  
  8.     public synchronized void read(){                   
  9.         if(ready){                           //2.1  
  10.             result = number*3;      //2.2  
  11.         }         
  12.         System.out.println(”result的值为：” + result);  
  13.     }  
//写操作
    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);
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

        最后的结果为：

 

        不可见原因：                          synchronized解决方案：

        1)线程的交叉执行                     —>原子性

        2)重排序结合线程交叉执行       —>原子性

        3)共享变量未及时更新              —>可见性

 

        三volatile实现可见性

        (1)volatile关键字：

 

        1)能够保证volatile变量的可见性

        2)不能保证volatile变量复合操作的原子性

        (2)volatile如何实现内存可见性：

        深入来说：通过加入内存屏障和禁止重排序优化来实现的。

        1)对volatile变量执行写操作时，会在写操作后加入一条store屏障指令。

        2)对volatile变量执行读操作时，会在读操作后加入一条load屏障指令。

        通俗地讲：volatile变量在每次被线程访问时，都强迫从主内存中重读该变量的值，而当该变量发生变化时，又会

强迫线程将最新的值刷新到主内存，这样任何时刻，不同的线程总能看到该变量的最新值。

        线程写volatile变量的过程：

        1)改变线程工作内存中volatile变量副本的值。

        2)将改变后的副本的值从工作内存刷新到主内存。

        线程读volatile变量的过程：

        1)从主内存中读取volatile变量的最新值到线程的工作内存中。

        2)从工作内存中读取volatile变量的副本。

        (3)volatile不能保证volatile变量复合操作的原子性

        对于下面的一段程序的使用volatile和synchronized

        private int number = 0;              

        number++;//不是原子操作                   

        1读取number的值                      

        2将number的值加1                    

        3写入最新的number的值  

        //加入synchronized，变为原子操作   

        synchronized(thhis){ 

              number++; 

        }

        //变为volatile变量，无法保证原子性

        private volatile int number = 0;

        (4)volatile不能保证原子性的实例代码：

 

[java] view plain copy

  1. import java.util.*;  
  2.   
  3. public class VolatileDemo {  
  4.     private volatile int number = 0;  
  5.       
  6.     public int getNumber(){  
  7.         return this.number;  
  8.     }  
  9.       
  10.     public void increase(){  
  11.         try {  
  12.             Thread.sleep(100);  
  13.         } catch (InterruptedException e) {  
  14.             e.printStackTrace();  
  15.         }  
  16.         this.number++;  
  17.     }  
  18.       
  19.     public static void main(String[] args) {  
  20.         final VolatileDemo volDemo = new VolatileDemo();  
  21.                 //在主线程中启动500个线程的++操作  
  22.         for(int i = 0 ; i < 500 ; i++){  
  23.             new Thread(new Runnable() {  
  24.                 public void run() {  
  25.                     volDemo.increase();  
  26.                 }  
  27.             }).start();  
  28.         }  
  29.           
  30.         //如果还有子线程在运行，主线程就让出CPU资源，  
  31.         //直到所有的子线程都运行完了，主线程再继续往下执行  
  32.         while(Thread.activeCount() > 1){  
  33.             Thread.yield();  
  34.         }  
  35.           
  36.         System.out.println(”number : ” + volDemo.getNumber());  
  37.     }  
  38. }  
import java.util.*;

public class VolatileDemo {
    private volatile int number = 0;

    public int getNumber(){
        return this.number;
    }

    public void increase(){
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.number++;
    }

    public static void main(String[] args) {
        final VolatileDemo volDemo = new VolatileDemo();
                //在主线程中启动500个线程的++操作
        for(int i = 0 ; i < 500 ; i++){
            new Thread(new Runnable() {
                public void run() {
                    volDemo.increase();
                }
            }).start();
        }

        //如果还有子线程在运行，主线程就让出CPU资源，
        //直到所有的子线程都运行完了，主线程再继续往下执行
        while(Thread.activeCount() > 1){
            Thread.yield();
        }

        System.out.println("number : " + volDemo.getNumber());
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37

 

        输出的结果基本都接近500：

        解决方案：

        保证number自增操作的原子操作

        1)使用synchronized关键字

        2)JDK1.5以后使用ReentrantLock(java.util.concurrent.locks包下)

        3)JDK1.5以后使用At.tomicIterger(java.util.concurrent.atomic包下)

        使用synchronized关键字保证原子性修改后的代码：

 

[java] view plain copy

  1.        private int number = 0;  
  2.   
  3. public int getNumber(){  
  4.     return this.number;  
  5. }  
  6.   
  7. public void increase(){  
  8.     try {  
  9.         Thread.sleep(100);  
  10.     } catch (InterruptedException e) {  
  11.         e.printStackTrace();  
  12.     }  
  13.     synchronized(this){  
  14.         this.number++;  
  15.     }  
  16. }  
        private int number = 0;

    public int getNumber(){
        return this.number;
    }

    public void increase(){
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synchronized(this){
            this.number++;
        }
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

         运行结果：

 

 

         使用ReentrantLock修改后的代码：

 

 

[java] view plain copy

  1.        private Lock lock = new ReentrantLock();  
  2. private int number = 0;  
  3.   
  4. public int getNumber(){  
  5.     return this.number;  
  6. }  
  7.   
  8. public void increase(){  
  9.     try {  
  10.         Thread.sleep(100);  
  11.     } catch (InterruptedException e) {  
  12.         e.printStackTrace();  
  13.     }  
  14.     lock.lock();  
  15.     try {  
  16.         this.number++;  
  17.     } finally {  
  18.         lock.unlock();  
  19. }  
        private Lock lock = new ReentrantLock();
    private int number = 0;

    public int getNumber(){
        return this.number;
    }

    public void increase(){
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        lock.lock();
        try {
            this.number++;
        } finally {
            lock.unlock();
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

         运行结果：同上

 

         (5) volatile使用注意volatile适用场合

         要在多线程中安全使用volatile变量，必须同时满足：

         1)对变量的写入操作不依赖其当前值

         不满足：number++  count=count*5等

         满足：boolean变量、记录温度变化的变量

         2)该变量没有包含在具有其他变量的不变式中。不满足：不变式low<up

         四总结

         (1)synchronized与volatile的比较

         1)volatile比synchronized更轻量级。

         2)volatile没有synchronized使用的广泛。

         3)volatile不需要加锁，比synchronized更轻量级，不会哦阻塞线程。

         4)从内存可见性角度看，volatile读相当于加锁，volatile写相当于解锁。

         5)synchronized既能保证可见性，又能保证原子性，而volatile只能保证可见性，无法保证原子性。

         6)volatile本身不保证获取和设置操作的原子性，仅仅保持修改的可见性。但是java的内存模型保证声明为

volatile的long和double变量的get和set操作是原子的。

         (2)补充1

         共享数据的访问权限都必须定义为private。一般是考虑安全性，对数据提供保护，可以通过set()方法赋值，再

通过get()方法取值，这就是java封装的思想。

        Java中对共享数据操作的并发控制是采用加锁技术。

        Java中没有提供检测与避免死锁的专门机制，但应用程序员可以采用某些策略防止死锁的发生。

        final也可以保证内存可见性。

        (3)补充2

        对64位(long、double)变量的读写可能不是原子操作

        Java内存模型允许JVM将没有被volatile修饰的64位数据类型的读写操作划分为两次32位的读写操作来运行。

        导致问题：有可能会出现读取到半个变量的情况。

        解决方法：加volatile关键字。

        (4)一个问题

        即使没有保证可见性的措施，很多时候共享变量依然能够在主内存和工作内存间得到及时的更新？

        答：一般只有在短时间内高并发的情况下才会出现变量得不到及时更新的情况，因为CPU在执行时会很快地刷新

缓存，所以一般情况下很难看到这种问题。

        慢了不就不会刷新了。。。CPU运算快的话，在分配的时间片内就能完成所有工作：工作内从1->主内存->工作

内存2，然后这个线程就释放CPU时间片，这样一来就保证了数据的可见性。如果是慢了话CPU强行剥夺该线的资

源，分配给其它线程，该线程就需要等待CPU下次给该线程分配时间片，如果在这段时间内有别的线程访问共享变

量，可见性就没法保证了。

Micrle_007
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java可见性机制的原理
01-20
　当一个线程修改了共享变量时，另一个线程可以读取到这个修改后的值。 　· 内存屏障（Memory Barriers） 　处理器的一组指令，用于实现对内存操作的顺序限制。 　· 缓冲行 　CPU告诉缓存中可以分配的小存储...
线程范围内的共享变量
gaoxiaoweiandy的专栏
01-22 3671
1. 线程范围内的共享变量的概念 假设有2个线程，一个全局变量 int data。2个线程内的代码共用这一个变量的声明（data），但它们操作data时，data的值在这2个线程里是独立的，互不影响的。我们这里所说的互不影响，不是我们之前说的syncronized,（线程1先修改data值，读取data值，释放锁后，线程2才可修改data和读取data,这样的话data最终的值还会变为线程2最后修改的值）。我们现在要实现的是，线程1修改了data=1, 线程2也修改了同一个data变量...
Java多线程变量共享与隔离
热门推荐
骑个小蜗牛的博客
11-15 1万+
线程相关 线程的相关API Thread.currentThread().getName():获取当前线程的名字 start():1.启动当前线程2.调用线程中的run方法 run():通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中 currentThread():静态方法，返回执行当前代码的线程 getName():获取当前线程的名字 setName():设置当前线程的名字 yield():主动释放当前线程的执行权 join():在线程中插入执行另一个线程，该线程被阻塞，直
JavaSE学习53：细说多线程之内存可见性
life is wonderful
06-19 2581
一共享变量在线程间的可见性         (1)有关可见性的一些概念介绍         可见性：一个线程对共享变量值的修改，能够及实地被其他线程看到。         共享变量：如果一个变量在多个线程的工作内存中都存在副本，那么这个变量就是这几个线程的共享变量。所 有的变量都存储在主内存中。         线程的工作内存：每个线程都有自己独立的工作内存，里面保存该线程使用到的变量的
多线程——线程范围内变量的共享
qq_43751200的博客
09-28 4859
线程范围内的共享变量是指对同一个变量，几个线程同时对它进行写和读操作，而同一个线程读到的数据就是它自己写进去的数据。 1、未实现变量共享的例子： import java.util.Random; public class NotShareVarThread { private static int data = 0; public static void main(String[] args){ for(int i = 0; i < 2; i++){
解决多线程间共享变量线程安全问题的大杀器——ThreadLocal
YHJ
06-11 1万+
上一期，讲到了关于线程死锁、用户进程、用户线程的相关知识，不记得的小伙伴可以看看：字节跳动面试官问我：你知道线程死锁吗？用户线程、守护线程的概念与区别了解吗？ 这期，我们来聊一聊一个在Java并发编程中很重要的类：ThreadLocal 在多线程应用程序中，对共享变量进行读写的场景是很常见的。如果不使用一定的技术或方案，会引发各种线程安全的问题。常见解决线程安全的方式有synchronized、volatile等方式，但synchronized对性能的开销大，volatile不能保证原子性，所以这里介绍一个
Java并发：volatile内存可见性和指令重排
01-21
　工作内存中保存了主内存共享变量的副本，线程要操作这些共享变量，只能通过操作工作内存中的副本来实现，操作完毕之后再同步回到主内存当中。 　如何保证多个线程操作主内存的数据完整性是一个难题
java多线程安全性基础介绍.pptx
07-25
各线程之间变量不可见，线程通信通过共享主内存实现。 volatile 仅保证可见性 作用 不会被缓存在寄存器或其他对cpu不可见的地方 强制其他线程读主内存 编译器和运行时不会讲该变量的操作与其他内存操作一起重...
java代码-volatile的可见性 由于JVM运行的实体是线程 而每个线程创建时JVM都会为其创建工作内存 工作内存是每个线程的私有数据区域 而JAVA内存模型规定所有变量都存储在主内存 主内存是共享内存区域 所有线程都可以访问 但线程对变量的操作必须在工作内存中进行 首先要将变量从主内存拷贝到自己的工作内存空间，然后对变量操作，操作完成后再将变量写入主内存 不能直接操作主内存中的变量 各个线程的工作内存中存储主内存中的变量副本拷贝 因此不同的线程之间无法访问对方的工作内存 线
07-15
java代码-volatile的可见性 由于JVM运行的实体是线程 而每个线程创建时JVM都会为其创建工作内存 工作内存是每个线程的私有数据区域 而JAVA内存模型规定所有变量都存储在主内存 主内存是共享内存区域 所有线程...
多线程如何共享变量 -- Java内存模型
大雄送你走的博客
03-20 2514
目录 主内存和工作内存 为什么要分为主内存和工作内存 Java 内存模型和运行时数据区的区别 Java 内存模型中变量的定义 内存之间交互操作 参考 主内存和工作内存 Java 内存模型（JMM：Java Memory Model）规定了所有的变量都存储在主内存中。 每条线程还有自己的工作内存，工作内存中保存了该线程使用到的变量到主内存副本拷贝。 线程对变量的所有操作都必须在工作内存中进行，而不能直接读写主内存中的变量。 不同线程之间无法直接访问对方工作内存中的变量，线程间变量值的传递均需要在主内存来
多线程---4
qq_52206533的博客
06-05 275
文章目录1. volatile关键字2.多线程案例2.1单例模式2.1.1饿汉模式2.1.2懒汉模式---线程不安全2.1.3懒汉模式---线程安全2.1.4双重校验锁3.线程间的通信 1. volatile关键字 volatile是修饰一个变量的关键字 作用： 保证变量的可见性（分解为字节码指令后，有变量的指令行，变量有可见性） 建立一个内存屏障，禁止指令重排序。 使用场景： 多线程对共享变量的操作，如果代码行本身保证了原子性（读是原子性，写（修改，赋值）操作：值不依赖共享变量，比如是一个常量，
linux共享内存介绍
qq_34888036的博客
08-17 4701
由于进程通信的本质是要让两个不同的进程看到同一份资源，我们可以在物理内存上开辟一块空间，这块空间被称为共享内存，然后让这两个进程通过某种方式都能访问到这块内存，这样的话，两个进程之间就可以通信了。...
多进程和多线程数据共享
www_z_dd的博客
08-02 1506
多线程之间的数据共享是通过线程共享同一个进程的内存空间来实现的，因此多个线程可以直接访问相同的内存地址，从而实现数据的共享。这使得多线程编程更加方便，因为不需要像多进程那样使用额外的机制进行进程间通信。然而，多线程共享数据也带来了潜在的问题，比如数据竞争和并发访问问题。当多个线程同时访问共享的数据时，可能会导致数据的不一致性或损坏。因此，在进行多线程编程时，需要合理地处理数据共享，避免数据竞争。
线程的可见性（关键字volatile）
weixin_52104995的博客
10-13 204
线程的可见性是指当多个线程同时访问共享的变量时，一个线程对变量的修改能够被其他线程立即看到。如果没有正确处理线程的可见性，可能会导致数据不一致或者出现意料之外的结果。
Java中线程共享变量的可见性问题
weixin_54931655的博客
08-29 311
当一个线程进入synchronized代码块时，它会自动获取该对象的锁，并清空本地内存中该对象相关的变量值，强制从主内存中重新读取变量值。当一个线程修改了共享变量的值后，这个值会先被更新到该线程的本地内存中，而不是直接更新到主内存中。当一个变量被声明为volatile时，每个线程都会强制从主内存中读取该变量的值，并将自己本地内存中该变量相关的值刷新回主内存中。例如，如果一个线程修改了共享变量的值，而另一个线程在此之前已经从主内存中读取了旧值并进行了计算，那么它得到的结果可能是错误的。
使用volatile解决多线程中的可见性和有序性
最新发布
weixin_53216033的博客
11-23 917
happens-before规定了对共享变量的写操作对其他线程的读操作可见，它是可见性和有序性的一套规则总结，跑开以下happens-before规则，JMM并不能保证一个线程对共享变量的写，对于其他线程对该共享变量的读可见。注意：synchronized里代码块的指令仍然是可以被重排序的，volatile才能阻止重排序，但是如果共享变量是完全被synchronized保护的，那么这个共享变量在使用的过程中是不会有原子性和可见性以及有序性问题的。
多线程中的可见性问题
chenchaozzu的博客
08-16 3779
1.缓存导致的可见性问题 可见性问题是指一个线程修改了某一个共享变量的值时，其他线程是否能够立即知道这个修改。 对于串行程序来说，可见性问题是不存在的，因为你在任何一个操作步骤中修改了某个变量，在后续的步骤中读取这个变量的值时，读取的一定是修改后的新值。 在并行程序中，如果一个线程修改了某一个全局变量，那么其他线程未必可以马上知道这个改动。多核时代，每颗 CPU 都有自己的缓存，这时 CPU 缓存与内存的数据一致性就没那么容易解决了，一个CPU缓存中的变量对另外一个CPU是不可见的 如上图中，两个线程在
【JAVA核心知识】17.1：线程间变量共享
积
06-15 3185
变量共享是进行线程间通信的常用手段之一，java的内存模型（JMM）解决了可见性和有序性，我们则可以通过线程锁保证原子性。 共享继承Runnable将变量作为成员变量将变量定义为final直接访问 有变量： class ShareData { int num = 0; public synchronized void inrc() { num++; } public synchronized void desc() { nu
Java并发：线程共享变量可见性原理
区块链之美
04-02 1546
0、线程安全性：线程安全性包括两个方面，①可见性。②原子性。0.1、线程之间的通信：线程的通信是指线程之间以何种机制来交换信息。在命令式编程中，线程之间的通信机制有两种共享内存和消息传递。（1）在共享内存的并发模型里，线程之间共享程序的公共状态，线程之间通过写-读内存中的公共状态来隐式进行通信，典型的共享内存通信方式就是通过共享对象进行通信。（2）在消息传递的并发模型里，线程之间没有公共状态，线程...
synchronized线程可见性
08-22
synchronized 关键字在 Java 中用于...总结一下，synchronized 关键字不仅提供了互斥访问的能力，还提供了对共享变量的修改可见性。它确保了一个线程对共享变量的修改对其他线程是可见的，从而避免了数据不一致的问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值