多線程中遞迴鎖的實現

本文轉載自：http://blog.csdn.net/wtz1985/article/details/301637

在上一篇文章中,我已經闡述了多線程中簡單鎖的實現,可在結束的時候,我就提了那麼一個問題,那就是如果在一個鏈表中進行插入時,要進行查詢的操作,如果只是簡單的鎖,是沒法實現的。所以“遞迴鎖”就浮現於世了。

可能有些人看到遞迴這兩個字，有點傻了眼，其實也沒什麼的，簡單的介紹，就是進行簡單的計數而已。剛開始引用鎖的時候，就產生它，當在鎖沒有解開的時候，還要繼續用鎖，就簡單的加一，解開一把就減一，當計數為零時，就把鎖銷毀掉。下面用程式來簡單的闡述一下，遞迴鎖是怎麼實現的：

1、遞迴鎖介面的定義。（鎖的介面的定義已經在上一篇定義過了，這裡不再重複）

1. /*------ recursive_locker.h -------*/
3. #ifndef _RECURSIVE_H
4. #define _RECURSIVE_H
6. #include "locker.h"
8. Locker* recursive_locker_create(Locker* real_locker);
10. #endif /*_RECURSIVE_H*/

2、遞迴鎖的實現。

1. /*------ recursive_locker.c ------*/
3. #include "recursive_locker.h"
4. #include <stdlib.h>
5. #include <stdio.h>
6. #include <assert.h>
7. #include <string.h>
9. typedef struct _PrivInfo
10. {
11.   Locker*  real_locker;
12.   pthread_t current_pthread_locker;
13.   int locker_count;
14. }PrivInfo;
16. static int recursive_locker_lock(Locker* thiz)
17. {
18.   assert(thiz != NULL);
20.   PrivInfo* priv = thiz->priv;
21.   if(priv->current_pthread_locker == pthread_self())
22.   {
23.     priv->locker_count ++;
24.   }
25.   else
26.   {
28.     locker_lock(priv->real_locker);
29.     priv->lcoker_count = 1;
30.     priv->current_pthread_locker = pthread_self();
31.   }
33.   return 0;
34. }
36. static int recursive_locker_unlock(Locker* thiz)
37. {
38.   assert(thiz != NULL);
40.   PrivInfo* priv = thiz->priv;
41.   if(priv->current_>pthread_locker == pthread_self())
42.   {
43.     if(priv->locker_count == 1)
44.     {
45.       priv->locker_count = 0;
46.       priv->current_pthread_locker = 0;
47.       locker_unlock(priv->real_locker);
48.     }
49.     else
50.     {
51.           priv->locker_count --;
52.     }
53.   }
54.   else
55.   {
56.      assert(!"error");
57.   }
59.   return 0;
60. }
62. static void recursive_locker_destroy(Locker* thiz)
63. {
64.   assert(thiz != NULL);
66.   PrivInfo* priv = thiz->priv;
67.   locker_destroy(priv->real_locker);
68.   free(thiz);
70.   return ;
71. }
73. Locker* recursive_locker_create(Locker* real_locker)
74. {
75.   Locker* thiz = (Locker* )malloc(sizeof(Locker) + sizeof(PrivInfo));
76.   PrivInfo* priv = thiz->priv;
77.   priv->real_locker = real_locker;
78.   priv->current_pthread_locker = 0;
79.   priv->locker_count = 0;
81.   thiz->lock = recursive_locker_lock;
82.   thiz->unlock = recursive_locker_unlock;
83.   thiz->locker_destroy = recursive_locker_destroy;
85.   return thiz;
86. }

上面就是遞迴鎖的實現。如果對COM熟悉的話，這個遞迴鎖結構應該是比較簡單的，就是一個的計數器而已。有了這個遞迴鎖就不用愁在鏈表插入的時候，在進行查詢操作鎖會出現問題。