Implementation of recursive locks in multiple threads

This article Reprinted from: http://blog.csdn.net/wtz1985/article/details/301637

In the previous article, I have already elaborated on the Implementation of simple locks in multiple threads. At the end of the article, I raised the question that when inserting a chain table, the query operation cannot be implemented if it is just a simple lock. So the "recursive lock" emerged in the world.

Some people may see the word recursion, which is a bit silly. In fact, there is nothing. A simple introduction is just a simple counting. When the lock is referenced at the beginning, it will be generated. When the lock is not unlocked, we will continue to use the lock, simply add one, unlock one, then subtract one, when the count is zero, destroy the lock pin. The following describes how recursive locks are implemented using a program:

1. Recursive lock interface definition. (The definition of the lock interface has already been defined in the previous article. It will not be repeated here)

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. Implement recursive locks.

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. }

The above is the implementation of recursive locks. If you are familiar with COM, the recursive lock structure should be relatively simple, just a counter. With this recursive lock, you don't have to worry about the query operation lock when inserting the linked list.