Concurrency系列(四): 與Synchronizes-With同在

在談論Concurrency時，常常會看到許多文件、文章使用Synchronized-with這個詞彙，但是深入google你會發現，網路上關於這個詞的資訊並不多，C++官方文件也沒有提出很明確的定義或解釋，但是他們依舊繼續使用這個詞，只說明有一些操作可以建立synchronizes-with的關係，這個詞大家並沒有給出一個很明確的定義。
我先用自己的話向大家解釋什麼是synchronized-with

synchronized-with是個發生在兩個不同thread間的同步行為，當A synchronized-with B的時，代表A對記憶體操作的效果，對於B是可見的。而A和B是兩個不同的thread的某個操作。

你會發現，其實synchronized-with就是跨thread版本的happens-before。

從Java切入

當在一個multithread的環境下，你要如何確定thread A執行someVariable = 3，那麼其他thread能夠看到3真的被寫入someVariable?
實際上，有很多原因會讓其他thread不會立刻看到someVariable為3，可能是compiler做instruction reorder，把指令重排讓程式更有效率，也可能是someVariable還在register內、或是被處理器寫到cache，但還沒被寫到到main memory上，甚至是其他thread嘗試讀取someVariable的時後讀到舊的cache資料。
因此，Java必須要定義一些特殊的語法，像是volatile, synchronized, final來確保針對同一個變數的跨thread記憶體操作能夠正確的同步。

synchronized keyword

public class SynchronizedCounter {
  private int c = 0;
  public synchronized void increment() {
    c++;
  }
  public synchronized void decrement() {
    c--;
  }
  public synchronized int value() {
    return c;
  }
}

public class SynchronizedCounter {

private int c = 0;

public synchronized void increment() {

c++;

}

public synchronized void decrement() {

c--;

}

public synchronized int value() {

return c;

}

可以看到上面的程式碼中，每個方法前面都加了一個關鍵字synchronized，這個關鍵字有兩個效果

Mutual Exclusive
對同一個物件而言，不可能有兩個前綴synchronized的方法同時交錯執行，當一個thread正在執行前綴synchronized的方法時，其他想執行synchronized方法的thread會被擋住。
建立Happens Before關係

對同一個物件而言，當一個thread離開synchronized方法時，會自動對接下來呼叫synchronized方法的thread建立一個happens-before關係，前一個synchronized的方法對該物件所做的修改，保證對接下來進入synchronized方法的thread可見。
要確保這件事情，代表JVM必須要做兩件事，一個是在離開synchronized區段時，把local processor的cache寫入到記憶體內，另一個是在進入下一個synchronized前，要讓local cache失效，使處理器重新去main memory抓正確的值。這樣才能夠確保每次進入synchronized區段時，物件的狀態是最新的。

Volatile keyword

另一個常見的用法是Java的volatile，如果你將物件內的變數宣告為volatile，那麼不同thread對該變數的讀寫，保證是atomic的，而且會讀到最新寫入的值。如果我用正式一點的術語描述，就是 A write to a volatile field happens-before every subsequent read of that same volatile

thread create/join

Java在開新thread時，也會建立起跨thread的happens-before關係(其實就是synchronized-with)。當thread A呼叫Thread.start建立thread B時，thread A呼叫start之前對記憶體產生的影響對於thread B可見。
當thread A要結束時，thread B呼叫Thread.join等待thread A結束，此時也會建立起跨thread的happens-before關係，thread A結束前對記憶體的影響對於呼叫join之後的thread B可見。

圖解

這樣我們就能理解上圖了，左邊thread A確保每一行都happens-before下一行，右邊的thread B也確保每一行都happens-before下一行，因此如果我對unlock M和lock M建立了synchronized-with(跨thread的happens-before)的關係，那麼所有unlock M之前的效果，對於lock M之後都可見。

再來輪到C++

C++比Java討厭的地方在於，Java努力把各種底層的複雜性藏起來，讓上層的JVM提供一個一致的環境，得以達成Write Once, Run Anywhere的理想。但C++盡可能提供你所有你能做到的事情，即使你可能會誤用這些工具。
在2014年C++的官方標準文件（Standard for Programming Language C++）N4296的第12頁，提示了C++提供的同步操作，也就是使用atomic operation或是mutex：

The library defines a number of atomic operations and operations on mutexes that are specially identified as synchronization operations. These operations play a special role in making assignments in one thread visible to another.

如上所述，C++定義了一系列的atomic operation和mutex，來協助你建立跨thread間的同步關係。實際上還有更多語法可用，但我們來看一個簡單的mutex例子：

include<iostream> // std::cout
include<thread>   // std::thread
include<mutex>    // std::mutex
std::mutex mtx;   // mutex for critical section
int count = 0;
void printthreadid (int id) {
// critical section (exclusive access to std::cout signaled by locking mtx):
mtx.lock();
std::cout << "thread #" << id << " count:" << count << '\n';
count++;
mtx.unlock();
}
int main ()
{
std::thread threads[10];
// spawn 10 threads:
for (int i=0; i&lt;10; ++i)
threads[i] = std::thread(printthreadid,i+1);
for (auto&amp; th : threads) th.join();
return 0;
}

include<iostream> // std::cout

include<thread> // std::thread

include<mutex> // std::mutex

std::mutex mtx; // mutex for critical section

int count = 0;

void printthreadid (int id) {

// critical section (exclusive access to std::cout signaled by locking mtx):

mtx.lock();

std::cout << "thread #" << id << " count:" << count << '\n';

count++;

mtx.unlock();

}

int main ()

{

std::thread threads[10];

// spawn 10 threads:

for (int i=0; i<10; ++i)

threads[i] = std::thread(printthreadid,i+1);

for (auto& th : threads) th.join();

return 0;

}

上述的程式碼一次開10個thread，每個thread做的事情都一樣，印出傳入的參數和counter目前的值，之後把counter++。要是沒有加上mutex lock，因為thread間交錯執行，無法確保synchronized-with的關係，上個thread執行的效果無法保證傳遞給下一個thread，於是印的亂七八糟，counter數字也亂跳。
沒有加上mutex lock後果如下

thread #thread #thread #thread #12 count: count:00
3 count:0
thread #5 count:0
thread #4 count:0
6 count:2
thread #7 count:6
thread #8 count:7
thread #9 count:8
thread #10 count:9

thread #thread #thread #thread #12 count: count:00

3 count:0

thread #5 count:0

thread #4 count:0

6 count:2

thread #7 count:6

thread #8 count:7

thread #9 count:8

thread #10 count:9

加上lock之後，結果就正常多了，每個thread都正確地把內容印出來

thread #2 count:0
thread #1 count:1
thread #8 count:2
thread #4 count:3
thread #5 count:4
thread #6 count:5
thread #9 count:6
thread #7 count:7
thread #3 count:8
thread #10 count:9

thread #2 count:0

thread #1 count:1

thread #8 count:2

thread #4 count:3

thread #5 count:4

thread #6 count:5

thread #9 count:6

thread #7 count:7

thread #3 count:8

thread #10 count:9

再次回到Synchronizes-with

實際上，要建立synchornizes-with的關係有很多種不同層次的方法，Jeff Preshing介紹Synchorinzes-with的文章內提供了下面這張詳盡的圖，這張圖只是個大致的示意，實際上可能還有其他方法可以建立同步關係。

可以看到synchronizes-with是一種跨thread間的happens-before關係，此外我們可以透過mutex lock, thread create/join、Aquire and release Semantic來建立synchronized-with關係，因為Aquire and Release是另外一個較為複雜的概念，所以我打算另外開一篇文章再來談，其餘下有更底層的C++ atomic type, memory fence和volatile types等語法，之後再來介紹。

Opass Life

知世故而不世故是最善良的成熟

Concurrency系列(四): 與Synchronizes-With同在

從Java切入

synchronized keyword

Volatile keyword

thread create/join

圖解

再來輪到C++

再次回到Synchronizes-with

Reference

發佈留言取消回覆

從Java切入

synchronized keyword

Volatile keyword

thread create/join

圖解

再來輪到C++

再次回到Synchronizes-with

Reference

發佈留言 取消回覆

發佈留言取消回覆