• <ins id="pjuwb"></ins>
    <blockquote id="pjuwb"><pre id="pjuwb"></pre></blockquote>
    <noscript id="pjuwb"></noscript>
          <sup id="pjuwb"><pre id="pjuwb"></pre></sup>
            <dd id="pjuwb"></dd>
            <abbr id="pjuwb"></abbr>

            Zero Lee的專欄

            [轉]多線程隊列的算法優化

            原文來自于: http://www.parallellabs.com/2010/10/25/practical-concurrent-queue-algorithm/ 

            多線程隊列(Concurrent Queue)的使用場合非常多,高性能服務器中的消息隊列,并行算法中的Work Stealing等都離不開它。對于一個隊列來說有兩個最主要的動作:添加(enqueue)和刪除(dequeue)節點。在一個(或多個)線程在對一個隊列進行enqueue操作的同時可能會有一個(或多個)線程對這個隊列進行dequeue操作。因為enqueue和dequeue都是對同一個隊列里的節點進行操作,為了保證線程安全,一般在實現中都會在隊列的結構體中加入一個隊列鎖(典型的如pthread_mutex_t q_lock),在進行enqueue和dequeue時都會先鎖住這個鎖以鎖住整個隊列然后再進行相關的操作。這樣的設計如果實現的好的話一般性能就會很不錯了。以鏈表實現的隊列的結構體一般是這樣的:

            01
            02
            03
            04
            05
            struct queue_t {
                node_t *head;
                node_t *tail;
                pthread_mutex_t q_lock;
            };

            但是,這其中其實有一個潛在的性能瓶頸:enqueue和dequeue操作都要鎖住整個隊列,這在線程少的時候可能沒什么問題,但是只要線程數一多,這個鎖競爭所產生的性能瓶頸就會越來越嚴重。那么我們可不可以想辦法優化一下這個算法呢?當然可以!如果我們仔細想一想enqueue和dequeue的具體操作就會發現他們的操作其實不一定是沖突的。例如:如果所有的enqueue操作都是往隊列的尾部插入新節點,而所有的dequeue操作都是從隊列的頭部刪除節點,那么enqueue和dequeue大部分時候都是相互獨立的,我們大部分時候根本不需要鎖住整個隊列,白白損失性能!那么一個很自然就能想到的算法優化方案就呼之欲出了:我們可以把那個隊列鎖拆成兩個:一個隊列頭部鎖(head lock)和一個隊列尾部鎖(tail lock)。這樣這樣的設計思路是對了,但是如果再仔細思考一下它的實現的話我們會發現其實不太容易,因為有兩個特殊情況非常的tricky(難搞):第一種就是往空隊列里插入第一個節點的時候,第二種就是從只剩最后一個節點的隊列中刪除那個“最后的果實”的時候。

            為什么難搞呢?當我們向空隊列中插入第一個節點的時候,我們需要同時修改隊列的head和tail指針,使他們同時指向這個新插入的節點,換句話說,我們此時即需要拿到head lock又需要拿到tail lock。而另一種情況是對只剩一個節點的隊列進行dequeue的時候,我們也是需要同時修改head和tail指針使他們指向NULL,亦即我們需要同時獲得head和tail lock。有經驗的同學會立刻發現我們進入危險區了!是什么危險呢?死鎖!多線程編程中最臭名昭著的一種bug就是死鎖了。例如,如果線程A在鎖住了資源1后還想要獲取資源2,而線程B在鎖住了資源2后還想要獲取資源1,這時兩個線程誰都不能獲得自己想要的那個資源,兩個線程就死鎖了。所以我們要小心奕奕的設計這個算法以避免死鎖,例如保證enqueue和dequeue對head lock和tail lock的請求順序(lock ordering)是一致的等等。但是這樣設計出來的算法很容易就會包含多次的加鎖/解鎖操作,這些都會造成不必要的開銷,尤其是在線程數很多的情況下反而可能導致性能的下降。我的親身經歷就是在32線程時這個思路設計出來的算法性能反而下降了10%左右,原因就是加鎖/解鎖的開銷增加了。

            好在有聰明人早在96年就想到了一個更妙的算法。這個算法也是用了head和tail兩個鎖,但是它有一個關鍵的地方是它在隊列初始化的時候head和tail指針不為空,而是指向一個空節點。在enqueue的時候只要向隊列尾部添加新節點就好了。而dequeue的情況稍微復雜點,它要返回的不是頭節點,而是head->next,即頭節點的下一個節點。先來看偽代碼:

            01
            02
            03
            04
            05
            06
            07
            08
            09
            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
            typedef struct node_t {
                TYPE value;
                node_t *next
            } NODE;
             
            typedef struct queue_t {
                NODE *head;
                NODE *tail;
                LOCK q_h_lock;
                LOCK q_t_lock;
            } Q;
             
            initialize(Q *q) {
               node = new_node()   // Allocate a free node
               node->next = NULL   // Make it the only node in the linked list
               q->head = q->tail = node   // Both head and tail point to it
               q->q_h_lock = q->q_t_lock = FREE   // Locks are initially free
            }
             
            enqueue(Q *q, TYPE value) {
               node = new_node()       // Allocate a new node from the free list
               node->value = value     // Copy enqueued value into node
               node->next = NULL       // Set next pointer of node to NULL
               lock(&q->q_t_lock)      // Acquire t_lock in order to access Tail
                  q->tail->next = node // Link node at the end of the queue
                  q->tail = node       // Swing Tail to node
               unlock(&q->q_t_lock)    // Release t_lock
             
            dequeue(Q *q, TYPE *pvalue) {
               lock(&q->q_h_lock)   // Acquire h_lock in order to access Head
                  node = q->head    // Read Head
                  new_head = node->next       // Read next pointer
                  if new_head == NULL         // Is queue empty?
                     unlock(&q->q_h_lock)     // Release h_lock before return
                     return FALSE             // Queue was empty
                  endif
                  *pvalue = new_head->value   // Queue not empty, read value
                  q->head = new_head  // Swing Head to next node
               unlock(&q->q_h_lock)   // Release h_lock
               free(node)             // Free node
               return TRUE            // Queue was not empty, dequeue succeeded
            }

            發現玄機了么?是的,這個算法中隊列總會包含至少一個節點。dequeue每次返回的不是頭節點,而是頭節點的下一個節點中的數據:如果head->next不為空的話就把這個節點的數據取出來作為返回值,同時再把head指針指向這個節點,此時舊的頭節點就可以被free掉了。這個在隊列初始化時插入空節點的技巧使得enqueue和dequeue徹底相互獨立了。但是,還有一個小地方在實現的時候需要注意:對第一個空節點的next指針的讀寫。想象一下,當一個線程對一個空隊列進行第一次enqueue操作時剛剛運行完第25行的代碼(對該空節點的next指針進行寫操作);而此時另一個線程對這個隊列進行第一次dequeue操作時恰好運行到第33行(對該空節點的next指針進行讀操作),它們其實還是有沖突!不過,好在一般來講next指針是32位數據,而現代的CPU已經能保證多線程程序中內存對齊了的32位數據讀寫操作的原子性,而一般來講編譯器會自動幫你對齊32位數據,所以這個不是問題。唯一需要注意的是我們要確保enqueue線程是先讓要添加的新節點包含好數據再把新節點插入鏈表(也就是不能先插入空節點,再往節點中填入數據),那么dequeue線程就不會拿到空的節點。其實我們也可以把q_t_lock理解成生產者的鎖,q_h_lock理解成消費者的鎖,這樣生產者(們)和消費者(們)的操作就相互獨立了,只有在多個生產者對同一隊列進行添加操作時,以及多個消費者對同一隊列進行刪除操作時才需要加鎖以使訪問互斥。

            通過使用這個算法,我成功的把一個32線程程序的性能提升了11%!可見多線程中的鎖競爭對性能影響之大!此算法出自一篇著名的論文:M. Michael and M. Scott. Simple, Fast, and Practical Non-Blocking and Blocking Concurren Queue Algorithms. 如果還想做更多優化的話可以參考這篇論文實現相應的Non Blocking版本的算法,性能還能有更多提升。當然了,這個算法早已被集成到java.util.concurrent里了(即LinkedBlockingQueue),其他的并行庫例如Intel的TBB多半也有類似的算法,如果大家能用上現成的庫的話就不要再重復造輪子了。為什么別造并行算法的輪子呢?因為高性能的并行算法實在太難正確地實現了,尤其是Non Blocking,Lock Free之類的“火箭工程”。有多難呢?Doug Lea提到java.util.concurrent中一個Non Blocking的算法的實現大概需要1年的時間,總共約500行代碼。所以,對最廣大的程序員來說,別去寫Non Blocking, Lock Free的代碼,只管用就行了,我看見網上很多的Non Blocking阿,無鎖編程的算法實現啊什么的都非常地害怕,誰敢去用他們貼出來的這些代碼啊?我之所以推薦這個two lock的算法是因為它的實現相對Non Blocking之類的來說容易多了,非常具備實用價值。雖然這篇論文出現的很早,但是我在看了幾個開源軟件中多線程隊列的實現之后發現他們很多還是用的本文最開始提到的那種一個鎖的算法。如果你想要實現更高性能的多線程隊列的話,試試這個算法吧!

            Update: 多線程隊列算法有很多種,大家應根據不同的應用場合選取最優算法(例如是CPU密集型還是IO密集型)。本文所列的算法應用在這樣一個多線程程序中:每個線程都擁有一個隊列,每個隊列可能被本線程進行dequeue操作,也可以被其他線程進行dequeue(即work stealing),線程數不超過CPU核心數,是一個典型的CPU/MEM密集型客戶端單寫者多讀者場景。

            posted on 2012-06-05 14:26 Zero Lee 閱讀(1250) 評論(0)  編輯 收藏 引用

            中文国产成人精品久久不卡| 欧美激情精品久久久久久久| 亚洲精品无码久久一线| 亚洲精品无码久久久久| .精品久久久麻豆国产精品| 99久久精品无码一区二区毛片| 四虎久久影院| 国产精品成人精品久久久 | 精品久久久久久久久久久久久久久 | 久久国产免费观看精品| 国内精品久久久久久久影视麻豆| 无码任你躁久久久久久| 久久免费视频观看| 久久丫忘忧草产品| 久久婷婷五月综合97色直播| 天天躁日日躁狠狠久久| 国产福利电影一区二区三区久久久久成人精品综合 | 日韩精品久久久久久久电影| 热re99久久6国产精品免费| 色综合久久88色综合天天 | 久久精品夜夜夜夜夜久久| 亚洲另类欧美综合久久图片区| 99久久精品影院老鸭窝| 久久丫精品国产亚洲av| 欧美午夜精品久久久久久浪潮| 久久亚洲高清观看| 久久精品国产亚洲av水果派| 欧美久久久久久精选9999| 久久久久免费精品国产| 粉嫩小泬无遮挡久久久久久| 亚洲?V乱码久久精品蜜桃| 久久久这里有精品| 久久久久人妻精品一区三寸蜜桃 | 9191精品国产免费久久| 久久久久亚洲AV无码麻豆| 无码AV波多野结衣久久| 亚洲国产精品高清久久久| 日韩欧美亚洲综合久久| 久久国产劲爆AV内射—百度| 模特私拍国产精品久久| 久久精品国产亚洲αv忘忧草|