多线程中递归锁的实现

本文转载自：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. typedefstruct_PrivInfo
10. {
11. Locker*real_locker;
12. pthread_tcurrent_pthread_locker;
13. intlocker_count;
14. }PrivInfo;
16. staticintrecursive_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. return0;
34. }
36. staticintrecursive_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. return0;
60. }
62. staticvoidrecursive_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. returnthiz;
86. }

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