2. 程式人生 > >Linux 的多執行緒程式設計的高效開發經驗

Linux 的多執行緒程式設計的高效開發經驗

阿新 • • 發佈：2018-12-18

背景

Linux 平臺上的多執行緒程式開發相對應其他平臺（比如 Windows）的多執行緒 API 有一些細微和隱晦的差別。不注意這些 Linux 上的一些開發陷阱，常常會導致程式問題不窮，死鎖不斷。本文中我們從 5 個方面總結出 Linux 多執行緒程式設計上的問題，並分別引出相關改善的開發經驗，用以避免這些的陷阱。我們希望這些經驗可以幫助讀者們能更好更快的熟悉 Linux 平臺的多執行緒程式設計。

我們假設讀者都已經很熟悉 Linux 平臺上基本的執行緒程式設計的 Pthread 庫 API 。其他的第三方用以執行緒程式設計的庫，如 boost，將不會在本文中提及。本文中主要涉及的題材包括執行緒開發中的執行緒管理，互斥變數，條件變數等。程序概念將不會在本文中涉及。

Linux 上執行緒開發 API 的概要介紹

多執行緒開發在 Linux 平臺上已經有成熟的 Pthread 庫支援。其涉及的多執行緒開發的最基本概念主要包含三點：執行緒，互斥鎖，條件。其中，執行緒操作又分執行緒的建立，退出，等待 3 種。互斥鎖則包括 4 種操作，分別是建立，銷燬，加鎖和解鎖。條件操作有 5 種操作：建立，銷燬，觸發，廣播和等待。其他的一些執行緒擴充套件概念，如訊號燈等，都可以通過上面的三個基本元素的基本操作封裝出來。

執行緒，互斥鎖，條件在 Linux 平臺上對應的 API 可以用表 1 歸納。為了方便熟悉 Windows 執行緒程式設計的讀者熟悉 Linux 多執行緒開發的 API，我們在表中同時也列出 Windows SDK 庫中所對應的 API 名稱。

表 1. 執行緒函式列表

物件 操作 Linux Pthread API Windows SDK 庫對應 API
執行緒 建立 pthread_create CreateThread
退出 pthread_exit ThreadExit
等待 pthread_join WaitForSingleObject
互斥鎖 建立 pthread_mutex_init CreateMutex
銷燬 pthread_mutex_destroy CloseHandle
加鎖 pthread_mutex_lock WaitForSingleObject
解鎖 pthread_mutex_unlock ReleaseMutex
條件 建立 pthread_cond_init CreateEvent
銷燬 pthread_cond_destroy CloseHandle
觸發 pthread_cond_signal SetEvent
廣播 pthread_cond_broadcast SetEvent / ResetEvent
等待 pthread_cond_wait / pthread_cond_timedwait SingleObjectAndWait

多執行緒開發在 Linux 平臺上已經有成熟的 Pthread 庫支援。其涉及的多執行緒開發的最基本概念主要包含三點：執行緒，互斥鎖，條件。其中，執行緒操作又分執行緒的建立，退出，等待 3 種。互斥鎖則包括 4 種操作，分別是建立，銷燬，加鎖和解鎖。條件操作有 5 種操作：建立，銷燬，觸發，廣播和等待。其他的一些執行緒擴充套件概念，如訊號燈等，都可以通過上面的三個基本元素的基本操作封裝出來。

Linux 執行緒程式設計中的 5 條經驗

儘量設定 recursive 屬性以初始化 Linux 的互斥變數

互斥鎖是多執行緒程式設計中基本的概念，在開發中被廣泛使用。其呼叫次序層次清晰簡單：建鎖，加鎖，解鎖，銷燬鎖。但是需要注意的是，與諸如 Windows 平臺的互斥變數不同，在預設情況下，Linux 下的同一執行緒無法對同一互斥鎖進行遞迴加速，否則將發生死鎖。

所謂遞迴加鎖，就是在同一執行緒中試圖對互斥鎖進行兩次或兩次以上的行為。其場景在 Linux 平臺上的程式碼可由清單 1 所示。

清單 1. Linux 重複對互斥鎖加鎖例項

1

		<p>2</p>

		<p>3</p>

		<p>4</p>

		<p>5</p>

		<p>6</p>

		<p>7</p>

		<p>8</p>

		<p>9</p>

		<p>10</p>

		<p>11</p>

		<p>12</p>
		</td>
		<td>
		<p><code>// 通過預設條件建鎖</code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>pthread_mutex_t *theMutex = new pthread_mutex_t; </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>pthread_mutexattr_t attr; </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>pthread_mutexattr_init(&amp;attr); </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>pthread_mutex_init(theMutex,&amp;attr); </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>pthread_mutexattr_destroy(&amp;attr); </code></p>

		<p>&nbsp;</p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>// 遞迴加鎖</code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>pthread_mutex_lock (theMutex); </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>pthread_mutex_lock (theMutex); </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>pthread_mutex_unlock (theMutex); </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>pthread_mutex_unlock (theMutex);</code></p>
		</td>
	</tr></tbody></table><p>在以上程式碼場景中，問題將出現在第二次加鎖操作。由於在預設情況下，Linux 不允許同一執行緒遞迴加鎖，因此在第二次加鎖操作時執行緒將出現死鎖。</p>

Linux 互斥變數這種奇怪的行為或許對於特定的某些場景會所有用處，但是對於大多數情況下看起來更像是程式的一個 bug 。畢竟，在同一執行緒中對同一互斥鎖進行遞迴加鎖在尤其是二次開發中經常會需要。

這個問題與互斥鎖的中的預設 recursive 屬性有關。解決問題的方法就是顯式地在互斥變數初始化時將設定起 recursive 屬性。基於此，以上程式碼其實稍作修改就可以很好的執行，只需要在初始化鎖的時候加設定一個屬性。請看清單 2 。

清單 2. 設定互斥鎖 recursive 屬性例項

1

		<p>2</p>

		<p>3</p>

		<p>4</p>
		</td>
		<td>
		<p><code>pthread_mutexattr_init(&amp;attr); </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>// 設定 recursive 屬性</code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>pthread_mutexattr_settype(&amp;attr,PTHREAD_MUTEX_RECURSIVE_NP); </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>pthread_mutex_init(theMutex,&amp;attr);</code></p>
		</td>
	</tr></tbody></table><p>因此，建議儘量設定 recursive 屬性以初始化 Linux 的互斥鎖，這樣既可以解決同一執行緒遞迴加鎖的問題，又可以避免很多情況下死鎖的發生。這樣做還有一個額外的好處，就是可以讓 Windows 和 Linux 下讓鎖的表現統一。</p>

注意 Linux 平臺上觸發條件變數的自動復位問題

條件變數的置位和復位有兩種常用模型：第一種模型是當條件變數置位（signaled）以後，如果當前沒有執行緒在等待，其狀態會保持為置位（signaled），直到有等待的執行緒進入被觸發，其狀態才會變為復位（unsignaled），這種模型的採用以 Windows 平臺上的 Auto-set Event 為代表。其狀態變化如圖 1 所示：

圖 1. Windows 的條件變數狀態變化流程

Windows 的條件變數狀態變化流程

第二種模型則是 Linux 平臺的 Pthread 所採用的模型，當條件變數置位（signaled）以後，即使當前沒有任何執行緒在等待，其狀態也會恢復為復位（unsignaled）狀態。其狀態變化如圖 2 所示：

圖 2. Linux 的條件變數狀態變化流程

Linux 的條件變數狀態變化流程

具體來說，Linux 平臺上 Pthread 下的條件變數狀態變化模型是這樣工作的：呼叫 pthread_cond_signal() 釋放被條件阻塞的執行緒時，無論存不存在被阻塞的執行緒，條件都將被重新復位，下一個被條件阻塞的執行緒將不受影響。而對於 Windows，當呼叫 SetEvent 觸發 Auto-reset 的 Event 條件時，如果沒有被條件阻塞的執行緒，那麼條件將維持在觸發狀態，直到有新的執行緒被條件阻塞並被釋放為止。

這種差異性對於那些熟悉 Windows 平臺上的條件變數狀態模型而要開發 Linux 平臺上多執行緒的程式設計師來說可能會造成意想不到的尷尬結果。試想要實現一個旅客坐計程車的程式：旅客在路邊等計程車，呼叫條件等待。計程車來了，將觸發條件，旅客停止等待並上車。一個計程車只能搭載一波乘客，於是我們使用單一觸發的條件變數。這個實現邏輯在第一個模型下即使出租車先到，也不會有什麼問題，其過程如圖 3 所示：

圖 3. 採用 Windows 條件變數模型的計程車例項流程

索引使用的容量要求

然而如果按照這個思路來在 Linux 上來實現，程式碼看起來可能是清單 3 這樣。

清單 3. Linux 計程車案例程式碼例項

1

		<p>2</p>

		<p>3</p>

		<p>4</p>

		<p>5</p>

		<p>6</p>

		<p>7</p>

		<p>8</p>

		<p>9</p>

		<p>10</p>

		<p>11</p>

		<p>12</p>

		<p>13</p>

		<p>14</p>

		<p>15</p>

		<p>16</p>

		<p>17</p>

		<p>18</p>

		<p>19</p>

		<p>20</p>

		<p>21</p>

		<p>22</p>

		<p>23</p>

		<p>24</p>

		<p>25</p>

		<p>26</p>

		<p>27</p>

		<p>28</p>

		<p>29</p>

		<p>30</p>

		<p>31</p>

		<p>32</p>

		<p>33</p>

		<p>34</p>

		<p>35</p>

		<p>36</p>

		<p>37</p>

		<p>38</p>

		<p>39</p>

		<p>40</p>

		<p>41</p>
		</td>
		<td>
		<p><code>……</code></p>

		<p><code>&nbsp;</code><code>// 提示計程車到達的條件變數</code></p>

		<p><code>&nbsp;</code><code>pthread_cond_t taxiCond; </code></p>

		<p>&nbsp;</p>

		<p><code>&nbsp;</code><code>// 同步鎖</code></p>

		<p><code>&nbsp;</code><code>pthread_mutex_t taxiMutex; </code></p>

		<p>&nbsp;</p>

		<p><code>&nbsp;</code><code>// 旅客到達等待計程車</code></p>

		<p><code>&nbsp;</code><code>void * traveler_arrive(void * name) { </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>cout&lt;&lt; ” Traveler: ” &lt;&lt;(char *)name&lt;&lt; ” needs a taxi now! ” &lt;&lt;endl; </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>pthread_mutex_lock(&amp;taxiMutex); </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>pthread_cond_wait (&amp;taxiCond, &amp;taxtMutex); </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>pthread_mutex_unlock (&amp;taxtMutex); </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>cout&lt;&lt; ” Traveler: ” &lt;&lt; (char *)name &lt;&lt; ” now got a taxi! ” &lt;&lt;endl; </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>pthread_exit( (void *)0 ); </code></p>

		<p><code>&nbsp;</code><code>} </code></p>

		<p>&nbsp;</p>

		<p><code>&nbsp;</code><code>// 計程車到達</code></p>

		<p><code>&nbsp;</code><code>void * taxi_arrive(void *name) { </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>cout&lt;&lt; ” Taxi ” &lt;&lt;(char *)name&lt;&lt; ” arrives. ” &lt;&lt;endl; </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>pthread_cond_signal(&amp;taxtCond); </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>pthread_exit( (void *)0 ); </code></p>

		<p><code>&nbsp;</code><code>} </code></p>

		<p>&nbsp;</p>

		<p><code>&nbsp;</code><code>void main() {&nbsp; </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>// 初始化</code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>taxtCond= PTHREAD_COND_INITIALIZER; </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>taxtMutex= PTHREAD_MUTEX_INITIALIZER; </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>pthread_t thread; </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>pthread_attr_t threadAttr; </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>pthread_attr_init(&amp;threadAttr); </code></p>

		<p>&nbsp;</p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>pthread_create(&amp;thread, &amp; threadAttr, taxt_arrive, (void *)( ” Jack ” )); </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>sleep(1); </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>pthread_create(&amp;thread, &amp;threadAttr, traveler_arrive, (void *)( ” Susan ” )); </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>sleep(1); </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>pthread_create(&amp;thread, &amp;threadAttr, taxi_arrive, (void *)( ” Mike ” )); </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>sleep(1); </code></p>

		<p>&nbsp;</p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>return 0; </code></p>

		<p><code>&nbsp;</code><code>}</code></p>
		</td>
	</tr></tbody></table><p>好的，執行一下，看看結果如清單 4 。</p>

清單 4. 程式結果輸出

1

		<p>2</p>

		<p>3</p>

		<p>4</p>
		</td>
		<td>
		<p><code>Taxi Jack arrives. </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>Traveler Susan needs a taxi now! </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>Taxi Mike arrives. </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>Traveler Susan now got a taxi.</code></p>
		</td>
	</tr></tbody></table><p>其過程如圖 4 所示：</p>

圖 4. 採用 Linux 條件變數模型的計程車例項流程

圖 4. 採用Linux條件變數模型的計程車例項流程

通過對比結果，你會發現同樣的邏輯，在 Linux 平臺上執行的結果卻完全是兩樣。對於在 Windows 平臺上的模型一， Jack 開著計程車到了站臺，觸發條件變數。如果沒顧客，條件變數將維持觸發狀態，也就是說 Jack 停下車在那裡等著。直到 Susan 小姐來了站臺，執行等待條件來找出租車。 Susan 搭上 Jack 的計程車離開，同時條件變數被自動復位。

但是到了 Linux 平臺，問題就來了，Jack 到了站臺一看沒人，觸發的條件變數被直接復位，於是 Jack 排在等待佇列裡面。來遲一秒的 Susan 小姐到了站臺卻看不到在那裡等待的 Jack，只能等待，直到 Mike 開車趕到，重新觸發條件變數，Susan 才上了 Mike 的車。這對於在排隊系統前面的 Jack 是不公平的，而問題癥結是在於 Linux 平臺上條件變數觸發的自動復位引起的一個 Bug 。

條件變數在 Linux 平臺上的這種模型很難說好壞。但是在實際開發中，我們可以對程式碼稍加改進就可以避免這種差異的發生。由於這種差異只發生在觸發沒有被執行緒等待在條件變數的時刻，因此我們只需要掌握好觸發的時機即可。最簡單的做法是增加一個計數器記錄等待執行緒的個數，在決定觸發條件變數前檢查下該變數即可。改進後 Linux 函式如清單 5 所示。

清單 5. Linux 計程車案例程式碼例項

1

		<p>2</p>

		<p>3</p>

		<p>4</p>

		<p>5</p>

		<p>6</p>

		<p>7</p>

		<p>8</p>

		<p>9</p>

		<p>10</p>

		<p>11</p>

		<p>12</p>

		<p>13</p>

		<p>14</p>

		<p>15</p>

		<p>16</p>

		<p>17</p>

		<p>18</p>

		<p>19</p>

		<p>20</p>

		<p>21</p>

		<p>22</p>

		<p>23</p>

		<p>24</p>

		<p>25</p>

		<p>26</p>

		<p>27</p>

		<p>28</p>

		<p>29</p>

		<p>30</p>

		<p>31</p>

		<p>32</p>

		<p>33</p>

		<p>34</p>

		<p>35</p>

		<p>36</p>

		<p>37</p>

		<p>38</p>

		<p>39</p>

		<p>40</p>

		<p>41</p>

		<p>42</p>

		<p>43</p>

		<p>44</p>
		</td>
		<td>
		<p><code>……</code></p>

		<p><code>&nbsp;</code><code>// 提示計程車到達的條件變數</code></p>

		<p><code>&nbsp;</code><code>pthread_cond_t taxiCond; </code></p>

		<p>&nbsp;</p>

		<p><code>&nbsp;</code><code>// 同步鎖</code></p>

		<p><code>&nbsp;</code><code>pthread_mutex_t taxiMutex; </code></p>

		<p>&nbsp;</p>

		<p><code>&nbsp;</code><code>// 旅客人數，初始為 0 </code></p>

		<p><code>&nbsp;</code><code>int travelerCount=0; </code></p>

		<p>&nbsp;</p>

		<p><code>&nbsp;</code><code>// 旅客到達等待計程車</code></p>

		<p><code>&nbsp;</code><code>void * traveler_arrive(void * name) { </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>cout&lt;&lt; ” Traveler: ” &lt;&lt;(char *)name&lt;&lt; ” needs a taxi now! ” &lt;&lt;</code><code>endl</code><code>; </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>pthread_mutex_lock(&amp;taxiMutex); </code></p>

		<p>&nbsp;</p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>// 提示旅客人數增加</code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>travelerCount++; </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>pthread_cond_wait (&amp;taxiCond, &amp;taxiMutex); </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>pthread_mutex_unlock (&amp;taxiMutex); </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>cout&lt;&lt; ” Traveler: ” &lt;&lt; (char *)name &lt;&lt; ” now got a taxi! ” &lt;&lt;endl; </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>pthread_exit( (void *)0 ); </code></p>

		<p><code>&nbsp;</code><code>} </code></p>

		<p>&nbsp;</p>

		<p><code>&nbsp;</code><code>// 計程車到達</code></p>

		<p><code>&nbsp;</code><code>void * taxi_arrive(void *name) </code></p>

		<p><code>&nbsp;</code><code>{ </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>cout&lt;&lt; ” Taxi ” &lt;&lt;(char *)name&lt;&lt; ” arrives. ” &lt;&lt;endl; </code></p>

		<p>&nbsp;</p>

		<p><code>&nbsp;</code><code>while(true) </code></p>

		<p><code>&nbsp;</code><code>{ </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code>pthread_mutex_lock(&amp;taxiMutex); </code></p>

		<p>&nbsp;</p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code>// 當發現已經有旅客在等待時，才觸發條件變數</code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code>if(travelerCount&gt;0) </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code>{ </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code>pthread_cond_signal(&amp;taxtCond); </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code>pthread_mutex_unlock (&amp;taxiMutex); </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code>break; </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code>} </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code>pthread_mutex_unlock (&amp;taxiMutex); </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>} </code></p>

		<p>&nbsp;</p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>pthread_exit( (void *)0 ); </code></p>

		<p><code>&nbsp;</code><code>}</code></p>
		</td>
	</tr></tbody></table><p>因此我們建議在 Linux 平臺上要出發條件變數之前要檢查是否有等待的執行緒，只有當有執行緒在等待時才對條件變數進行觸發。</p>

注意條件返回時互斥鎖的解鎖問題

在 Linux 呼叫 pthread_cond_wait 進行條件變數等待操作時，我們增加一個互斥變數引數是必要的，這是為了避免執行緒間的競爭和飢餓情況。但是當條件等待返回時候，需要注意的是一定不要遺漏對互斥變數進行解鎖。

Linux 平臺上的 pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex) 函式返回時，互斥鎖 mutex 將處於鎖定狀態。因此之後如果需要對臨界區資料進行重新訪問，則沒有必要對 mutex 就行重新加鎖。但是，隨之而來的問題是，每次條件等待以後需要加入一步手動的解鎖操作。正如前文中乘客等待計程車的 Linux 程式碼如清單 6 所示：

清單 6. 條件變數返回後的解鎖例項

1

		<p>2</p>

		<p>3</p>

		<p>4</p>

		<p>5</p>

		<p>6</p>

		<p>7</p>

		<p>8</p>
		</td>
		<td>
		<p><code>void * traveler_arrive(void * name) { </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>cout&lt;&lt; ” Traveler: ” &lt;&lt;(char *)name&lt;&lt; ” needs a taxi now! ” &lt;&lt;endl; </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>pthread_mutex_lock(&amp;taxiMutex); </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>pthread_cond_wait (&amp;taxiCond, &amp;taxtMutex); </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>pthread_mutex_unlock (&amp;taxtMutex); </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>cout&lt;&lt; ” Traveler: ” &lt;&lt; (char *)name &lt;&lt; ” now got a taxi! ” &lt;&lt;endl; </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>pthread_exit( (void *)0 ); </code></p>

		<p><code>&nbsp;</code><code>}</code></p>
		</td>
	</tr></tbody></table><p>這一點對於熟悉 Windows 平臺多執行緒開發的開發者來說尤為重要。 Windows 上的 SignalObjectAndWait() 函式是常與 Linux 平臺上的 pthread_cond_wait() 函式被看作是跨平臺程式設計時的一對等價函式。但是需要注意的是，兩個函式退出時的狀態是不一樣的。在 Windows 平臺上，SignalObjectAndWait(HANDLE a, HANDLE b, …… ) 方法在呼叫結束返回時的狀態是 a 和 b 都是置位（signaled）狀態，在普遍的使用方法中，a 經常是一個 Mutex 變數，在這種情況下，當返回時，Mutex a 處於解鎖狀態（signaled），Event b 處於置位狀態（signaled）, 因此，對於 Mutex a 而言，我們不需要考慮解鎖的問題。而且，在 SignalObjectAndWait() 之後，如果需要對臨界區資料進行重新訪問，都需要呼叫 WaitForSingleObject() 重新加鎖。這一點剛好與 Linux 下的 pthread_cond_wait() 完全相反。</p>

Linux 對於 Windows 的這一點額外解鎖的操作區別很重要，一定得牢記。否則從 Windows 移植到 Linux 上的條件等待操作一旦忘了結束後的解鎖操作，程式將肯定會發生死鎖。

等待的絕對時間問題

超時是多執行緒程式設計中一個常見的概念。例如，當你在 Linux 平臺下使用 pthread_cond_timedwait() 時就需要指定超時這個引數，以便這個 API 的呼叫者最多隻被阻塞指定的時間間隔。但是如果你是第一次使用這個 API 時，首先你需要了解的就是這個 API 當中超時引數的特殊性（就如本節標題所提示的那樣）。我們首先來看一下這個 API 的定義。 pthread_cond_timedwait() 定義請看清單 7 。

清單 7. pthread_cond_timedwait() 函式定義

1

		<p>2</p>

		<p>3</p>
		</td>
		<td>
		<p><code>int pthread_cond_timedwait(pthread_cond_t *restrict cond, </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code>pthread_mutex_t *restrict mutex, </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code>const struct timespec *restrict abstime);</code></p>
		</td>
	</tr></tbody></table><p>引數 abstime 在這裡用來表示和超時時間相關的一個引數，但是需要注意的是它所表示的是一個絕對時間，而不是一個時間間隔數值，只有當系統的當前時間達到或者超過 abstime 所表示的時間時，才會觸發超時事件。這對於擁有 Windows 平臺執行緒開發經驗的人來說可能尤為困惑。因為 Windows 平臺下所有的 API 等待引數（如 SignalObjectAndWait，等）都是相對時間，</p>

假設我們指定相對的超時時間引數如 dwMilliseconds （單位毫秒）來呼叫和超時相關的函式，這樣就需要將 dwMilliseconds 轉化為 Linux 下的絕對時間引數 abstime 使用。常用的轉換方法如清單 8 所示：

清單 8. 相對時間到絕對時間轉換例項

1

		<p>2</p>

		<p>3</p>

		<p>4</p>

		<p>5</p>

		<p>6</p>

		<p>7</p>
		</td>
		<td>
		<p><code>/* get the current time */ </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>struct timeval now; </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>gettimeofday(&amp;now, NULL); </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code>&nbsp;</p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>/* add the offset to get timeout value */ </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>abstime -&gt;tv_nsec = now.tv_usec * 1000 + (dwMilliseconds % 1000) * 1000000; </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>abstime -&gt;tv_sec = now.tv_sec + dwMilliseconds / 1000;</code></p>
		</td>
	</tr></tbody></table><p>Linux 的絕對時間看似簡單明瞭，卻是開發中一個非常隱晦的陷阱。而且一旦你忘了時間轉換，可以想象，等待你的錯誤將是多麼的令人頭疼：如果忘了把相對時間轉換成絕對時間，相當於你告訴系統你所等待的超時時間是過去式的 1970 年 1 月 1 號某個時間段，於是作業系統毫不猶豫馬上送給你一個 timeout 的返回值，然後你會舉著拳頭抱怨為什麼另外一個同步執行緒耗時居然如此之久，並一頭扎進尋找耗時原因的深淵裡。</p>

正確處理 Linux 平臺下的執行緒結束問題

在 Linux 平臺下，當處理執行緒結束時需要注意的一個問題就是如何讓一個執行緒善始善終，讓其所佔資源得到正確釋放。在 Linux 平臺預設情況下，雖然各個執行緒之間是相互獨立的，一個執行緒的終止不會去通知或影響其他的執行緒。但是已經終止的執行緒的資源並不會隨著執行緒的終止而得到釋放，我們需要呼叫 pthread_join() 來獲得另一個執行緒的終止狀態並且釋放該執行緒所佔的資源。 Pthread_join() 函式的定義如清單 9 。

清單 9. pthread_join 函式定義

1

int pthread_join(pthread_t th, void **thread_return);

呼叫該函式的執行緒將掛起，等待 th 所表示的執行緒的結束。 thread_return 是指向執行緒 th 返回值的指標。需要注意的是 th 所表示的執行緒必須是 joinable 的，即處於非 detached（遊離）狀態；並且只可以有唯一的一個執行緒對 th 呼叫 pthread_join() 。如果 th 處於 detached 狀態，那麼對 th 的 pthread_join() 呼叫將返回錯誤。

如果你壓根兒不關心一個執行緒的結束狀態，那麼也可以將一個執行緒設定為 detached 狀態，從而來讓作業系統在該執行緒結束時來回收它所佔的資源。將一個執行緒設定為 detached 狀態可以通過兩種方式來實現。一種是呼叫 pthread_detach() 函式，可以將執行緒 th 設定為 detached 狀態。其申明如清單 10 。

清單 10. pthread_detach 函式定義

1

int pthread_detach(pthread_t th);

另一種方法是在建立執行緒時就將它設定為 detached 狀態，首先初始化一個執行緒屬性變數，然後將其設定為 detached 狀態，最後將它作為引數傳入執行緒建立函式 pthread_create()，這樣所創建出來的執行緒就直接處於 detached 狀態。方法如清單 11 。

清單 11. 建立 detach 執行緒程式碼例項

1

		<p>2</p>

		<p>3</p>

		<p>4</p>

		<p>5</p>

		<p>6</p>
		</td>
		<td>
		<p><code>………………………………… .. </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>pthread_t&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; tid; </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>pthread_attr_t&nbsp; attr; </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>pthread_attr_init(&amp;attr); </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>pthread_attr_setdetachstate(&amp;attr, PTHREAD_CREATE_DETACHED); </code></p>

		<p><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>pthread_create(&amp;tid, &amp;attr, THREAD_FUNCTION, arg);</code></p>
		</td>
	</tr></tbody></table><p>總之為了在使用 Pthread 時避免執行緒的資源線上程結束時不能得到正確釋放，從而避免產生潛在的記憶體洩漏問題，在對待執行緒結束時，要確保該執行緒處於 detached 狀態，否著就需要呼叫 pthread_join() 函式來對其進行資源回收。</p>

總結與補充

本文以上部分詳細介紹了 Linux 的多執行緒程式設計的 5 條高效開發經驗。另外你也可以考慮嘗試其他一些開源類庫來進行執行緒開發。

1. Boost 庫

Boost 庫來自於由 C++ 標準委員會類庫工作組成員發起，致力於為 C++ 開發新的類庫的 Boost 組織。雖然該庫本身並不是針對多執行緒而產生，但是發展至今，其已提供了比較全面的多執行緒程式設計的 API 支援。 Boost 庫對於多執行緒支援的 API 風格上更類似於 Linux 的 Pthread 庫，差別在於其將執行緒，互斥鎖，條件等執行緒開發概念都封裝成了 C++ 類，以方便開發呼叫。 Boost 庫目前對跨平臺支援的很不錯，不僅支援 Windows 和 Linux ，還支援各種商用的 Unix 版本。如果開發者想使用高穩定性的統一執行緒程式設計介面減輕跨平臺開發的難度， Boost 庫將是首選。

2. ACE

ACE 全稱是 ADAPTIVE Communication Environment，它是一個免費的，開源的，面向物件的工具框架，用以開發併發訪問的軟體。由於 ACE 最初是面向網路服務端的程式設計開發，因此對於執行緒開發的工具庫它也能提供很全面的支援。其支援的平臺也很全面，包括 Windows，Linux 和各種版本 Unix 。 ACE 的唯一問題是如果僅僅是用於執行緒程式設計，其似乎顯得有些過於重量級。而且其較複雜的配置也讓其部署對初學者而言並非易事。

相關推薦

Linux多執行緒程式設計---執行緒間同步（互斥鎖、條件變數、訊號量和讀寫鎖）

本篇博文轉自http://zhangxiaoya.github.io/2015/05/15/multi-thread-of-c-program-language-on-linux/ Linux下提供了多種方式來處理執行緒同步，最常用的是互斥鎖、條件變數、訊號量和讀寫鎖。  下面是思維導

linux多執行緒程式設計，用 pthread_cond_timedwait 代替sleep

摘要：多執行緒程式設計中，執行緒A迴圈計算，然後sleep一會接著計算（目的是減少CPU利用率）；存在的問題是，如果要關閉程式，通常選擇join執行緒A等待執行緒A退出，可是我們必須等到sleep函式返回，該執行緒A才能正常退出，這無疑減慢了程式退出的速度。當然，你可以terminate執行緒A，但

Linux多執行緒程式設計

執行緒概念     執行緒是指執行中的程式的排程單位。一個執行緒指的是程序中一個單一順序的控制流，也被稱為輕量級執行緒。它是系統獨立排程和分配的基本單位。同一程序中的多個執行緒將共享該系統中的全部系統資源，比如檔案描述符和訊號處理等。一個程序可以有很多執行緒，每

Linux多執行緒程式設計入門

1 執行緒基本知識 程序是資源管理的基本單元，而執行緒是系統排程的基本單元，執行緒是作業系統能夠進行排程運算的最小單位，它被包含在程序之中，是程序中的實際運作單位。一條執行緒指的是程序中一個單一順序的控制流，一個程序中可以併發多個執行緒，每條執行緒並行執行不同

Linux多執行緒程式設計小結

 Linux多執行緒程式設計小結 前一段時間因為開題的事情一直耽擱了我搞Linux的進度，搞的我之前學的東西都遺忘了，很煩躁的說，現在抽個時間把之前所學的做個小節。文章內容主要總結於《Linux程式設計第3版》。 1.Linux程序與執行緒 Linux程序建立一個新執行緒時

Linux 多執行緒程式設計（一）

Linux 多執行緒程式設計 執行緒（Thread）已被許多作業系統所支援，包括Windows/NT ,Linux 以前的多執行緒其實是多程序，而現在意味著一個程序中有多個執行緒 使用多執行緒的原因（多執行緒的優點）： 1.“節省”，啟動一個新的程序需要分配給它獨立的地

Linux多執行緒程式設計之員工資訊管理系統

       員工資訊管理系統是基於Linux 多執行緒併發伺服器程式設計，由伺服器端和客戶端構成，客戶端可以執行在多個不同的主機上連線伺服器，伺服器對員工資訊的操作結果通過“員工資訊檔案”來儲存，即：“員工資訊”存放在後臺的檔案中，相當於資料庫。當用戶登入後，根據使用者名稱

linux多執行緒程式設計，你還在用sleep麼？用pthread_cond_timedwait吧

摘要：多執行緒程式設計中，執行緒A迴圈計算，然後sleep一會接著計算（目的是減少CPU利用率）；存在的問題是，如果要關閉程式，通常選擇join執行緒A等待執行緒A退出，可是我們必須等到sleep函式返回，該執行緒A才能正常退出，這無疑減慢了程式退出的速度。當然，你可以terminate執行緒A，但這樣做

Linux多執行緒同步機制 .linux多執行緒程式設計機制

#include <stdio.h> #include <pthread.h> #include <unistd.h> pthread_mutex_t mutex; pthread_cond_t  cond; void * child1(void *arg) {      

（Linux多執行緒程式設計（不限Linux））多執行緒操作

——本文一個例子展開，介紹Linux下面執行緒的操作、多執行緒的同步和互斥。 前言 執行緒？為什麼有了程序還需要執行緒呢，他們有什麼區別？使用執行緒有什麼優勢呢？還有多執行緒程式設計的一些細節問題，如執行緒之間怎樣同步、互斥，這些東西將在本文中介紹。我在某QQ群裡見到這樣一道面試題： 是否熟悉POS

Linux多執行緒程式設計講解之系列六

執行緒安全介紹 在目前的電腦科學中，執行緒是作業系統排程的最小單元，程序是資源分配的最小單元。在大多數作業系統中，一個程序可以同時派生出多個執行緒。這些執行緒獨立執行，共享程序的資源。在單處理器系統中，多執行緒通過分時複用技術來技術，處理器在不同的執行緒間切換，從而更高效地利用系統 CPU資源。

Linux多執行緒程式設計講解之系列五

在Posix執行緒規範中還有幾個輔助函式難以歸類，暫且稱其為雜項函式，主要包括pthread_self()、pthread_equal()和pthread_once()三個，另外還有一個LinuxThreads非可移植性擴充套件函式pthread_kill_other_t

linux多執行緒程式設計(C)：訊號量實現的執行緒安全佇列

用訊號量實現的執行緒安全佇列。 簡單有用的示例程式， 比起互斥量的實現在多執行緒時效率更好。 cir_queue.h /* * \File * cir_queue.h * \Brief * circular queue */#ifndef __CIR_QUEUE_H_

Linux多執行緒程式設計———重點區分

多執行緒 執行緒（thread）技術早在60年代就被提出，但真正應用多執行緒到作業系統中去，是在80年代中期，solaris是這方面的佼佼者.傳統的Unix也支援執行緒的概念，但是在一個程序（process）中只允許有一個執行緒，這樣多執行緒就意味著多程序.現

linux多執行緒程式設計——同步與互斥

我們在前面文章中已經分析了多執行緒VS多程序，也分析了執行緒的使用，現在我們來講解一下linux多執行緒程式設計之同步與互斥。 現在，我們不管究竟是多執行緒好還是多程序好，先講解一下，為什麼要使用多執行緒？ 一、 為什麼要用多執行緒技術？ 1、避免阻塞，大家知道，單個程序只

Linux多執行緒程式設計講解之系列一

Linux執行緒概述瞭解如何正確運用執行緒是每一個優秀程式設計師必備的素質。執行緒類似於程序。如同程序，執行緒由核心按時間分片進行管理。在單處理器系統中，核心使用時間分片來模擬執行緒的併發執行，這種方式和程序的相同。而在多處理器系統中，如同多個程序，執行緒實際上一樣可以併發

Linux多執行緒程式設計學習(1)--執行緒的概念和執行緒控制

Linux多執行緒程式設計學習總結 一.執行緒的概念 1.什麼是執行緒？ 2.程序和執行緒的區別 3.程序和執行緒的關係 4.執行緒的優缺點 4.1 優點 4.2 缺點 5.執行

Linux多執行緒程式設計例項解析

Linux系統下的多執行緒遵循POSIX執行緒介面，稱為 pthread。編寫Linux下的多執行緒程式，需要使用標頭檔案pthread.h，連線時需要使用庫libpthread.a。順便說一下，Linux 下pthread的實現是通過系統呼叫clone（）來實現的。clo

Linux多執行緒程式設計時如何檢視一個程序中的某個執行緒是否存活

pthread_kill： 別被名字嚇到，pthread_kill可不是kill，而是向執行緒傳送signal。還記得signal嗎，大部分signal的預設動作是終止程序的執行，所以，我們才要用signal()去抓訊號並加上處理函式。 int pthread_kil

linux多執行緒程式設計--對三層for迴圈的優化

目標：將下面3層for迴圈的程式碼進行優化： #include <iostream> #include <vector> #include <pthread.h> using namespace std; typedef vecto