2. 程式人生 > >Java多執行緒：記憶體可見性

Java多執行緒：記憶體可見性

阿新 • • 發佈：2019-02-14

Java中對於volatile變數，通俗點說可以把它看做多執行緒之間分享的共享記憶體，可見性是立即的。

實際上它分成了兩部分，volatile write和volatile read。由於Unsafe提供了getXXXVolatile和putXXXVolatile介面。所以這樣一來Java中對於能夠共享的變數，至少有四種訪問方式：

普通寫、普通讀、putXXXVolatile、getXXXVolatile。

另一方面，像是陣列元素Object[] objs，我們僅能將objs宣告為volatile，而這樣的話對於其中的元素 objs[0]、objs[1]是完全沒有效用的，也就是說，兩種宣告方式：Object[] objs和volatile Object[] objs，對於其中的元素是一樣的。此種情況下只能使用Unsafe提供的介面來保證記憶體可見性。

所以此文來探索下類似於volatile寫 + 普通讀， 普通寫 + volatile讀， 這樣的情況下是不是真的無法保證可見性。

volatile寫 + 普通讀

首先來看一個簡單粗暴的例子我們往一個初始化為空的長度30000的Object[]中寫入資料。另一個執行緒早在寫入資料開始前就從下標0嘗試讀取資料，假如讀到的==null則進入while的迴圈。除非讀到了!=null，則列印資料：

package com.psly.locksupprot;

import com.psly.testatomic.UtilUnsafe;

import sun.misc.Unsafe;

public class TestVolatileSemantics2 {
	private static final Unsafe _unsafe = UtilUnsafe.getUnsafe();
	private static final int _Obase  = _unsafe.arrayBaseOffset(Object[].class);
	private static final int _Oscale = _unsafe.arrayIndexScale(Object[].class);
	
	private final static int N = 30000;
	private final static Object[] B = new Object[N+1];
	
	private static class Node {
		public Node(int value){
			this.value = value;
		}
		private int value;
	}
	public static void main(String[] args) throws InterruptedException {
		Thread writer = new Thread(new Runnable(){
			@Override
			public void run() {
				for(int i = 1; i <= N; ++i){
					_unsafe.putObjectVolatile(B, _Obase + i * _Oscale, new Node(1));
				}
				System.out.println("Done");
			}
		});
		
		Thread reader = new Thread(new Runnable(){
			public void run(){
				for(int i = 1; i <= N; ++i){
					while(B[i] == null){}
					System.out.println(((Node)B[i]).value + " " + i +  " first reader");	}				
				}
			}
		);
		reader.start();
		Thread.sleep(1000);
		writer.start();
	}
}
在我的電腦上執行它的輸出僅有為： 
Done
並且始終佔據電腦的cpu資源。

儘管我們稍微修改下程式碼，修改讀執行緒的方式，採取遍歷整個資料組，如果不為null則輸出。那麼它看似是可以讀到的：

package com.psly.locksupprot;

import com.psly.testatomic.UtilUnsafe;

import sun.misc.Unsafe;

public class TestVolatileSemantics2 {
	private static final Unsafe _unsafe = UtilUnsafe.getUnsafe();
	private static final int _Obase  = _unsafe.arrayBaseOffset(Object[].class);
	private static final int _Oscale = _unsafe.arrayIndexScale(Object[].class);
	
	private final static int N = 30000;
	private final static Object[] B = new Object[N+1];
	
	private static class Node {
		public Node(int value){
			this.value = value;
		}
		private int value;
	}
	public static void main(String[] args) throws InterruptedException {
		Thread writer = new Thread(new Runnable(){
			@Override
			public void run() {
				for(int i = 1; i <= N; ++i){
					_unsafe.putObjectVolatile(B, _Obase + i * _Oscale, new Node(1));
				}
				System.out.println("Done");
			}
		});
		
		Thread reader = new Thread(new Runnable(){
			public void run(){
				for(;;){
					for(int i = 1; i <= N; ++i){
						if(B[i] != null){
							System.out.println(((Node)B[i]).value + " " + i +  " first reader");	
							}	
						}
					}
				}
			}
		);
		reader.start();
		Thread.sleep(1000);
		writer.start();
	}

}
輸出為：
1 23132 first reader
1 23133 first reader
1 23134 first reader
1 23135 first reader
1 23136 first reader
1 23137 first reader
1 23138 first reader
1 23139 first reader
1 23140 first reader
1 23141 first reader
1 23142 first reader
1 23143 first reader
1 23144 first reader
1 23145 first reader
1 23146 first reader
1 23147 first reader
1 23148 first reader
1 23149 first reader
1 23150 first reader
1 23151 first reader
1 23152 first reader
1 23153 first reader
1 23154 first reader
1 23155 first reader
1 23156 first reader
1 23157 first reader
1 23158 first reader
1 23159 first reader
1 23160 first reader
1 23161 first reader
1 23162 first reader
但是假如要證明一個規則成立，則必須確保所有符合假設的情況下都成立。而證明一件事情不成立，只需要舉一個例子。

所以根據之前的例子，volatile寫（compareAndSwapXXX也是一樣的） + 普通讀，無法保證後者取到更新後的資料。

（更正之前的說法，事實上是，這裡的B對應的讀取，因為編譯器的優化導致B[i]沒有讀到更新後的值。）

（事實上，只要volatile寫之後，無論怎麼讀都可以讀到更新後的值，只要編譯器不參與優化）（我的推測）

所以對於最上面的那個例子，我們採用在B前面新增volatile或者讀取使用volatile讀就可以解決了，程式碼如下：

package com.psly;

import sun.misc.Unsafe;

public class TestVolatileSemantics2 {
	private static final Unsafe _unsafe = UtilUnsafe.getUnsafe();
	private static final int _Obase  = _unsafe.arrayBaseOffset(Object[].class);
	private static final int _Oscale = _unsafe.arrayIndexScale(Object[].class);
	
	private final static int N = 30000;
	private volatile static Object[] B = new Object[N+1];
	
	private static class Node {
		public Node(int value){
			this.value = value;
		}
		private int value;
	}
	public static void main(String[] args) throws InterruptedException {
		Thread writer = new Thread(new Runnable(){
			@Override
			public void run() {
				for(int i = 1; i <= N; ++i){
					_unsafe.putObjectVolatile(B, _Obase + i * _Oscale, new Node(1));
				}
				System.out.println("Done");
			}
		});
		
		Thread reader = new Thread(new Runnable(){
			public void run(){
				for(int i = 1; i <= N; ++i){
					while(B[i] == null){}
					System.out.println(((Node)B[i]).value + " " + i +  " first reader");	}				
				}
			}
		);
		reader.start();
		Thread.sleep(1000);
		writer.start();
	}
} 

package com.psly;

import sun.misc.Unsafe;

public class TestVolatileSemantics2 {
	private static final Unsafe _unsafe = UtilUnsafe.getUnsafe();
	private static final int _Obase  = _unsafe.arrayBaseOffset(Object[].class);
	private static final int _Oscale = _unsafe.arrayIndexScale(Object[].class);
	
	private final static int N = 30000;
	private final static Object[] B = new Object[N+1];
	
	private static class Node {
		public Node(int value){
			this.value = value;
		}
		private int value;
	}
	public static void main(String[] args) throws InterruptedException {
		Thread writer = new Thread(new Runnable(){
			@Override
			public void run() {
				for(int i = 1; i <= N; ++i){
					_unsafe.putObjectVolatile(B, _Obase + i * _Oscale, new Node(1));
				}
				System.out.println("Done");
			}
		});
		
		Thread reader = new Thread(new Runnable(){
			public void run(){
				for(int i = 1; i <= N; ++i){
					while(_unsafe.getObjectVolatile(B, _Obase + i * _Oscale) == null){}
					System.out.println(((Node)B[i]).value + " " + i +  " first reader");	}				
				}
			}
		);
		reader.start();
		Thread.sleep(1000);
		writer.start();
	}
}


普通寫 + volatile讀

我們也跟前面一樣舉一個反例。

但是在我構造的例子中，普通寫 + volatile讀都看似讀到了更新後的資料。但我們依然所以無法判斷究竟是否及時讀取到。


其中的Li4，critical section之前的c[i] :=false是寫入操作，c[j]為讀取操作，critical section之後的c[i]也是寫入操作。

好，我們用java實現這個演算法，第一個c[i]採用普通寫入，c[j]採用getIntVolatile讀入，後一個c[i]採用putIntVolatile寫入。

假設普通寫能夠被後面的volatile read讀取。那麼這裡一定能夠保證任意時刻只有一個執行緒處於critical section（根據演算法保證，可參考併發控制）。

我們在臨界區對變數+1，假如最後的值不符合預期，那麼就說明臨界區同時進入了不止一個執行緒，從而說明假設錯誤。

我們給出的程式碼如下：

package com.psly.testatomic;

import sun.misc.Unsafe;

public class TestVolatileDijkstraMethodWithNoBlock {

	//用於記憶體保證：putXXVolatile/getXXVolatile
	private static final Unsafe _unsafe = UtilUnsafe.getUnsafe();
	private static final int _Obase  = _unsafe.arrayBaseOffset(int[].class);
	private static final int _Oscale = _unsafe.arrayIndexScale(int[].class);
	//N：執行緒數，TIMES每個執行緒需要進入臨界區的次數。
	private final static int N = 3;
	private final static int TIMES = 1000000;
	
	private final static int[] B = new int[N+1];
	private final static int[] C = new int[N+1];
	//每個執行緒進入臨界區++count，最終count == N * TIMES
	private volatile static long count;
	//k與上面的count欄位類似
	private static int k = 1;
    private final static Object kObj;   
    private final static long kOffset; 
	static{
		for(int i = 1; i <= N; ++i){
			B[i] = 1;
			C[i] = 1;
		}
		  try {
			kObj = _unsafe.staticFieldBase(TestVolatileDijkstraMethodWithNoBlock.class.getDeclaredField("k"));
		} catch (Exception e) {
			// TODO Auto-generated catch block
			throw new Error(e);//e.printStackTrace();
		} 
          try {
			kOffset = _unsafe.staticFieldOffset(TestVolatileDijkstraMethodWithNoBlock.class.getDeclaredField("k"));
		} catch (Exception e) {
			// TODO Auto-generated catch block
			throw new Error(e);//e.printStackTrace();
		}
	}  

	final static void dijkstrasConcurMethod(int pM){
	    int times = TIMES;
        int i = pM;
    L0: for(;;){
    	B[i] = 0;
    L1: 	for(;;){
    			if( k != i ) {
    				//C[i] = 1;
    				if(B[_unsafe.getIntVolatile(kObj, kOffset)] == 1)
    					_unsafe.putIntVolatile(kObj, kOffset, i);//k = i;//k = i;
    				continue L1;
    			} else{       
    				C[i] = 0;
    				
    				for(int j = 1; j <= N; ++j ) 
    					if(j != i && _unsafe.getIntVolatile(C, _Obase + j * _Oscale) == 0){
    						//將C[i]的值更新回去，寫這裡效率更高
    						_unsafe.putIntVolatile(C, _Obase + i * _Oscale, 1);
    						continue L1;
    					}
    			}
    			break L1;
        	}
    	
    		//臨界區開始
        	++count;
        	//臨界區結束
        	
        	_unsafe.putIntVolatile(C, _Obase + i * _Oscale, 1);
        	B[i]=1;
        	if( --times != 0){
        		continue L0; //goto L0;
        	}
        	return;
        }
	}
	
	public static void main(String[] args) throws InterruptedException
	{
		//開始時間
		long start = System.currentTimeMillis();
		//列印累加器初始值
	    System.out.println( count + " initial\n");
	    Thread handle[] = new Thread[N+1];
        //建立執行緒
	    for (int i = 1; i <= N; ++i){
	    	int j = i;
		    handle[i] = new Thread(new Runnable(){
		    	@Override
		    	public void run(){
		    		dijkstrasConcurMethod(j);
		    	}
		    });
	    }
	    //執行緒開始執行
	    for (int i = 1; i <= N; ++i)
	        handle[i].start();
	    //主執行緒等待子執行緒結束
	    for (int i = 1; i <= N; ++i)
	        handle[i].join();
	    //列印累加值，== N * TIMES
	    System.out.println(count);
	  //列印程式執行時間
	    System.out.println((System.currentTimeMillis() - start) / 1000.0 + " milliseconds"); 
	}
}
3個執行緒，每個100000次，最後總共應該是3000000(count)。執行結果是： 
0 initial

2999599
0.178 milliseconds
這說明，普通寫 + volatile讀也是無法保證可見性的。

這裡改為volatile寫 + volatile讀，

_unsafe.putIntVolatile(C, _Obase + i * _Oscale, 0);//C[i] = 0;

就能夠得到正確結果：

0 initial

300000
0.023 milliseconds

所以我們的結論是，volatile寫 + 普通讀 和 普通寫 + volatile讀都無法保證可見性，請大家在需要及時看見共享記憶體更新的場景中統一採用volatile寫 + volatile讀。

以上未給出的UtilUnsafe如下：

package com.psly;  
  
import java.lang.reflect.Field;  
  
import sun.misc.Unsafe;  
  
public class UtilUnsafe {  
  private UtilUnsafe() { } // dummy private constructor  
  /** Fetch the Unsafe.  Use With Caution. */  
  public static Unsafe getUnsafe() {  
    // Not on bootclasspath  
    if( UtilUnsafe.class.getClassLoader() == null )  
      return Unsafe.getUnsafe();  
    try {  
      final Field fld = Unsafe.class.getDeclaredField("theUnsafe");  
      fld.setAccessible(true);  
      return (Unsafe) fld.get(UtilUnsafe.class);  
    } catch (Exception e) {  
      throw new RuntimeException("Could not obtain access to sun.misc.Unsafe", e);  
    }  
  }  
}


相關推薦

Java多執行緒：記憶體可見性

Java中對於volatile變數，通俗點說可以把它看做多執行緒之間分享的共享記憶體，可見性是立即的。 實際上它分成了兩部分，volatile write和volatile read。由於Unsafe提供了getXXXVolatile和putXXXVolatile介面。所以

Java多執行緒之記憶體可見性和原子性：Synchronized和Volatile的比較

在刷題時，碰到一題：關於volatile關鍵字的說法錯誤的是： A. 能保證執行緒安全 B volatile關鍵字用在多執行緒同步中，可保證讀取的可見性  C JVM保證從主記憶體載入到執行緒工做記憶體的值是最新的 D volatile能禁止指令進行指令重排序 答案：A 處

細說Java 多執行緒之記憶體可見性

前言： 討論學習Java中的記憶體可見性、Java記憶體模型、指令重排序、as-if-serial語義等多執行緒中偏向底層的一些知識，以及synchronized和volatile實現記憶體可見性的原理和方法。 1、可見性介紹 可見性：一個執行緒對共用變數值的修改，能夠及時地被其他執行緒

Java多執行緒之記憶體可見性實現方式

可見性的實現方式 Java語言層面支援的可見性實現方式: - synchronized - volatile synchronized實現可見性原理 synchronized可以實現: 原子性(同步) 可見性 JMM關於synchronized

java多執行緒之記憶體可見性

可見性：一個執行緒對共享變數值的修改，能夠及時地被其他執行緒看到。 共享變數：如果一個變數在多個執行緒的工作記憶體中都存在副本，那麼這個變數就是幾個執行緒的共享變數。  e.g：主記憶體當中有一個變數x，多個執行緒同時包含有一個x的副本，當某個執行緒的工作的x值改變的時候要及時地被執行緒看到。就會一個問題，

詳解Java多執行緒之記憶體可見性

可見性：一個執行緒對共享變數值的修改，能夠及時的被其他執行緒看到。  共享變數：如果一個電量在多個執行緒的工作記憶體中都存在副本，那麼這個變數就是這幾個執行緒的共享變數。 JAVA記憶體模型（Java Memory Model）描述了Java程式中各種變數（執行緒共享變

Java 中的多執行緒之記憶體可見性

1. Java記憶體模型（JMM） Java 記憶體模型（Java Memory Model）描述了Java程式中各種變數（執行緒共享變數）的訪問規則，以及在 JVM 中將變數儲存到記憶體和從記憶體中讀取出變數的底層細節。 所有的變數都儲存在

【JAVA】多執行緒之記憶體可見性

                                    多執行緒之記憶體可見性 一、什麼是可見性？ 一個執行緒對共享變數值的修改，能夠及時地被其他執行緒所看到。 共享變數：如果一個變數在多個執行緒的工作記憶體中都存在副本，那麼這個變數就是這幾個執行緒的共

多執行緒之記憶體可見性Volatile（一）

從這篇博文開始，我們開始分享一些多執行緒的內容，畢竟在工作中，使用多執行緒比較多。多總結一下，終歸沒有壞處。這個系列的文章不會特別長，爭取在3到5分鐘之間結束，主要以說明白內容，給出相應的解決方案，重點在於實踐。 如標題所示，這篇博文我們簡單的介紹一下記憶體可

5.多執行緒之記憶體可見性

共享變數線上程間的可見性 共享變數：如果一個變數在多個執行緒的工作記憶體中都存在副本， 那麼這個變數就是這幾個執行緒的共享變數 可見性：一個執行緒對共享變數值的修改，能夠及時的被其他執行緒看到 Java記憶體模型（JM

Java多執行緒和記憶體模型（一）：程序和執行緒基礎

Java多執行緒和記憶體模型（一） 由於java是執行在 JVM上 的，所以需要涉及到 JVM 的記憶體模型概念，需要理解記憶體模型，就需要多執行緒的基礎； 而執行緒是基於載體執行緒裡的，所以我們藉由作業系統的程序來講一講。 程序 什麼是程序？

十二、JAVA多執行緒：機器硬體CPU、Java記憶體模型

　　大家都知道，計算機在執行程式時，每條指令都是在CPU中執行的，而執行指令過程中，勢必涉及到資料的讀取和寫入。由於程式執行過程中的臨時資料是存放在主存（實體記憶體）當中的，這時就存在一個問題，由於CPU執行速度很快，而從記憶體讀取資料和向記憶體寫入資料的過程跟CPU執行指令的速度比起來要慢的多，因

JAVA 執行緒之記憶體可見性

什麼是記憶體可見性 先介紹幾個概念： 共享變數： 如果一個變數在多個執行緒的工作記憶體中都存在副本，那麼這個變數就是這幾個執行緒的共享變數 可見性： 一個執行緒對共享變數值的修改，能夠及時地被其他執行緒看到 JMM（ JAVA記憶體模型）

java多執行緒12.記憶體模型

假設一個執行緒為變數賦值：variable = 3；   記憶體模型需要解決一個問題：“在什麼條件下，讀取variable的執行緒將看到這個值為3？”   這看上去理所當然，但是如果缺少記憶體同步，那麼將會有許多因素使得執行緒無法立即甚至永遠，看到另一個執行緒的操作結果。 如：

java多執行緒：5.1 鎖-基礎

什麼是鎖 提到多執行緒，立馬就有人說加鎖，什麼是鎖，為什麼加鎖？ 鎖：從字面意義，什麼東西加了鎖，那麼就只有有鑰匙的人才能使用，多執行緒中的鎖，也是這個意思。 為什麼加鎖：當單執行緒的時候，無論訪問什麼資源，都不需要考慮鎖的問題，但是當多個執行緒訪問同一個資源，就會發生很多千奇百怪的

java多執行緒：3 執行緒狀態

執行緒從建立到結束執行，經過多個狀態，每個狀態對應著不同的操作，具體如下： 1 建立(new)，2 可以執行(runnable)、3 執行(running)、4 等待(waiting)、5 阻塞(blocked)、6 結束(dead) 建立執行緒 當通過new Thre

java多執行緒：2 建立執行緒

如何建立一個多執行緒： Java提供了java.lang.Thread類，這就是執行緒的定義類，包含了：執行緒的優先順序，執行緒id、執行緒狀態等執行緒的基本資訊。 通過Thread類的說明，可以知道建立執行緒的兩種方式：1 extends Thread類，2 implements

java多執行緒：1程序和執行緒

多執行緒樣例 我們用工人卸貨舉例：有一集裝箱的貨物等待卸車，共100個箱子，一個工人一次只能搬一個箱子。 如果只有一個工人，那麼該工人需要搬運100次，而且是不停歇的搬運。 如果有5個或者10個工人，那麼平均每個工人只需要搬運20或者10次就可以了。 甚至有1

Java多執行緒： 死鎖

                         

java多執行緒：執行緒的通訊、喚醒等待機制、生產消費者模式、Lock

執行緒的通訊：印表機列印–不斷的輸入輸出 package com.qianfeng.test; /* * 執行緒的通訊： * 分析： * 需要兩個執行緒--輸入執行緒和輸出執行緒 * 需要兩個任務--輸入任務和輸出任務 * 需要一份資料 * *