多线程中递归锁的实现.

在上一篇文章中,我已经阐述了多线程中简单锁的实现,可在结束的时候,我就提了那么一个问题,那就是如果在一个链表中进行插入时,要进行查询的操作,如果只是简单的锁,是没法实现的。所以“递归锁”就浮现于世了。

可能有些人看到递归这两个字，有点傻了眼，其实也没什么的，简单的介绍，就是进行简单的计数而已。刚开始引用锁的时候，就产生它，当在锁没有解开的时候，还要继续用锁，就简单的加一，解开一把就减一，当计数为零时，就把锁销毁掉。下面用程序来简单的阐述一下，递归锁是怎么实现的：

1、递归锁接口的定义。（锁的接口的定义已经在上一篇定义过了，这里不再重复）

1. #ifndef _RECURSIVE_H
2. #define _RECURSIVE_H
3. #include "locker.h"
4. Locker* recursive_locker_create(Locker* real_locker);
5. #endif 

2、递归锁的实现。

1. #include "recursive_locker.h"
2. #include 
3. #include 
4. #include 
5. #include 
6. typedef struct _PrivInfo
7. {
8.   Locker*  real_locker;
9.   pthread_t current_pthread_locker;
10.   int locker_count;
11. }PrivInfo;
12. static int recursive_locker_lock(Locker* thiz)
13. {
14.   assert(thiz != NULL);
15.   PrivInfo* priv = thiz->priv;
16.   if(priv->current_pthread_locker == pthread_self())
17.   {
18.     priv->locker_count ++;
19.   }
20.   else
21.   {
22.     locker_lock(priv->real_locker);
23.     priv->lcoker_count = 1;
24.     priv->current_pthread_locker = pthread_self();
25.   }
26.   return 0;
27. }
28. static int recursive_locker_unlock(Locker* thiz)
29. {
30.   assert(thiz != NULL);
31.   PrivInfo* priv = thiz->priv;
32.   if(priv->current_>pthread_locker == pthread_self())
33.   {
34.     if(priv->locker_count == 1)
35.     {
36.       priv->locker_count = 0;
37.       priv->current_pthread_locker = 0;
38.       locker_unlock(priv->real_locker);
39.     }
40.     else
41.     {
42.           priv->locker_count --;
43.     }
44.   }
45.   else
46.   {
47.      assert(!"error");
48.   }
49.   return 0;
50. }
51. static void recursive_locker_destroy(Locker* thiz)
52. {
53.   assert(thiz != NULL);
54.   PrivInfo* priv = thiz->priv;
55.   locker_destroy(priv->real_locker);
56.   free(thiz);
57.   return ;
58. }
59. Locker* recursive_locker_create(Locker* real_locker)
60. {
61.   Locker* thiz = (Locker* )malloc(sizeof(Locker) + sizeof(PrivInfo));
62.   PrivInfo* priv = thiz->priv;
63.   priv->real_locker = real_locker;
64.   priv->current_pthread_locker = 0;
65.   priv->locker_count = 0;
66.   thiz->lock = recursive_locker_lock;
67.   thiz->unlock = recursive_locker_unlock;
68.   thiz->locker_destroy = recursive_locker_destroy;
69.   return thiz;
70. }

上面就是递归锁的实现。如果对COM熟悉的话，这个递归锁结构应该是比较简单的，就是一个的计数器而已。有了这个递归锁就不用愁在链表插入的时候，在进行查询操作锁会出现问题。