多線程。如何平等地分享公共資源？

Question

簡單的代碼（我知道，這是一個非常糟糕的一個，但我做到了只是爲例子）：

1 #include <mutex> 
2 #include <iostream> 
3 #include <thread> 
4 
5 std::mutex mu; 
6 
7 void myFunc(void) { 
8   for (int i = 0; i < 100; ++i) { 
9     mu.lock(); 
10     std::cout << "CHILD Thread: " << std::this_thread::get_id() << std::endl; 
11     mu.unlock(); 
12   } 
13 } 
14 
15 int main() 
16 { 
17   std::thread thr(myFunc); 
18   for (int i = 0; i < 100; ++i) { 
19     mu.lock(); 
20     std::cout << "MAIN Thread: " << std::this_thread::get_id() << std::endl; 
21     mu.unlock(); 
22   } 
23   thr.join(); 
24   return 0; 
25 } 

返回此類型的輸出：

1  MAIN Thread: 140581832210240 
2  MAIN Thread: 140581832210240 
3  MAIN Thread: 140581832210240 
4  MAIN Thread: 140581832210240 
5  MAIN Thread: 140581832210240 
6  MAIN Thread: 140581832210240 
7  MAIN Thread: 140581832210240 
8  CHILD Thread: 140581814855424 
9  CHILD Thread: 140581814855424 
10  CHILD Thread: 140581814855424 
11  CHILD Thread: 140581814855424 
12  CHILD Thread: 140581814855424 
13  CHILD Thread: 140581814855424 
14  CHILD Thread: 140581814855424 
15  CHILD Thread: 140581814855424 
16  CHILD Thread: 140581814855424 
17  CHILD Thread: 140581814855424 
18  MAIN Thread: 140581832210240 
19  MAIN Thread: 140581832210240 
20  MAIN Thread: 140581832210240 
21  MAIN Thread: 140581832210240 
22  MAIN Thread: 140581832210240 
23  CHILD Thread: 140581814855424 
24  CHILD Thread: 140581814855424 
25  CHILD Thread: 140581814855424 
26  CHILD Thread: 140581814855424 
27  CHILD Thread: 140581814855424 
28  CHILD Thread: 140581814855424 
29  CHILD Thread: 140581814855424 
      ....... and so on 

，當我看到它 - 這個輸出失敗了多線程的含義，因爲一個線程需要等待很長一段時間。這個輸出應該同時給我兒童，主要的cout，兒童的cout，主要的cout等等。我知道互斥對於共享資源的公平分享不負責任，但是：誰是？我如何將其實施到我的程序中？

謝謝。

編輯：把性病::法院成一個函數：

10 void common_cout(string msg) { 
11   mu.lock(); 
12   std::cout << msg << std::endl; 
13   mu.unlock(); 
14 } 

犯規幫助。

Answer 1

原始代碼在Windows中有相同的問題，但我切換到使用原生Windows等價物，並且此窗口示例以您期望的方式工作，在兩個線程之間交替。 ReleaseMutex（）的每個實例都會導致「其他」線程獲取互斥鎖並正在運行。 Main中的Sleep（2）是確保myFunc首先啓動它的簡單方法。

我還創建了一個主線程和兩個線程的總共三個線程的版本。循環順序進行，所以看起來Windows本地互斥鎖是按請求的順序完成的。

對於循環型循環或線程和/或進程之間同步一般，使用每線程或進程一個信號量是更好的，因爲任何的線程或進程可以遞增（釋放/信號）的任何信號。與此相關的問題是信號量不是標準線程接口的本地部分，需要互斥量和條件變量的一些組合來實現等效的信號量。 Windows和posix支持本地信號量。

#include <iostream> 
#include <windows.h> 

static HANDLE mu;      // handle: mutex 
static HANDLE ht1;      // handle: thread 1 
static DWORD id1;      // thread 1 id 

DWORD WINAPI myFunc(LPVOID) { 
    for (int i = 0; i < 20; ++i) { 
     WaitForSingleObject(mu, INFINITE); 
     std::cout << "child thread: " << i << std::endl; 
     ReleaseMutex(mu); 
    } 
    return 0; 
} 

int main() 
{ 
    mu = CreateMutex(NULL,TRUE,NULL); // main owns mutex 
    ht1 = CreateThread(NULL, 0, myFunc, 0, 0, &id1); 
    Sleep(2);       // make sure myFunc running 
    ReleaseMutex(mu);     // release mutex 
    for (int i = 0; i < 20; ++i) { 
     WaitForSingleObject(mu, INFINITE); 
     std::cout << "main thread: " << i << std::endl; 
     ReleaseMutex(mu); 
    } 
    WaitForSingleObject(ht1, INFINITE); 
    CloseHandle(ht1); 
    CloseHandle(mu); 
    return 0; 
} 

輸出

child thread: 0 
main thread: 0 
child thread: 1 
main thread: 1 
... 
child thread: 18 
main thread: 18 
child thread: 19 
main thread: 19 

3線程例如：

#include <iostream> 
#include <windows.h> 

static HANDLE mu;      // handle: mutex 
static HANDLE ht0;      // handle: thread 0 
static HANDLE ht1;      // handle: thread 1 
static DWORD id0;      // thread 0 id 
static DWORD id1;      // thread 1 id 

DWORD WINAPI Thread0(LPVOID) { 
    for (int i = 0; i < 10; ++i) { 
     WaitForSingleObject(mu, INFINITE); 
     std::cout << "Thread0 : " << i << std::endl; 
     ReleaseMutex(mu); 
    } 
    return 0; 
} 

DWORD WINAPI Thread1(LPVOID) { 
    for (int i = 0; i < 10; ++i) { 
     WaitForSingleObject(mu, INFINITE); 
     std::cout << "Thread1 : " << i << std::endl; 
     ReleaseMutex(mu); 
    } 
    return 0; 
} 

DWORD WINAPI Thread2(LPVOID) { 
    for (int i = 0; i < 10; ++i) { 
     WaitForSingleObject(mu, INFINITE); 
     std::cout << "Thread2 : " << i << std::endl; 
     ReleaseMutex(mu); 
    } 
    return 0; 
} 

int main() 
{ 
    mu = CreateMutex(NULL,TRUE,NULL); // main owns mutex 
    ht0 = CreateThread(NULL, 0, Thread0, 0, 0, &id0); 
    ht1 = CreateThread(NULL, 0, Thread1, 0, 0, &id1); 
    Sleep(2);       // let other threads get started 
    ReleaseMutex(mu);     // release mutex 
    Thread2(0); 
    WaitForSingleObject(ht0, INFINITE); 
    WaitForSingleObject(ht1, INFINITE); 
    CloseHandle(ht0); 
    CloseHandle(ht1); 
    CloseHandle(mu); 
    return 0; 
} 

輸出

Thread0 : 0 
Thread1 : 0 
Thread2 : 0 
Thread0 : 1 
Thread1 : 1 
Thread2 : 1 
... 
Thread0 : 9 
Thread1 : 9 
Thread2 : 9 

Answer 2

我知道互斥對於共同資源的公平分享不負責任，但是：誰是？

實際調度是由您的操作系統完成的。

你還沒有說過這是什麼，但它是常見的而不是之間切換線程往往比不必要的，因爲它是低效的（有一些開關的成本）。

換句話說，您的「公平性」的想法 - 大概是每個線程輪流執行的嚴格的循環 - 將是一個昂貴的默認行爲。無論如何，如果它是你想要的，你可以明確地編碼它。公平調度程序的通常目標涉及到可運行線程需要等待多長時間，以及在線程仍在執行（可能是有用的工作）時預先佔用線程的頻率之間的某種平衡。

操作系統的行爲當然也取決於你擁有多少核心。你還沒有提到這個。

...而我如何將它實現到我的程序中？

如果你在你的線程中做了一些合理的實際工作量，你可能會發現你的調度程序的行爲更符合你的喜好。這種人爲測試很少給出有用的結果，特別是因爲您在緊密的循環中執行少量代碼。