Multi-thread lock implementation.

* Please refer to this document for reference from blog.csdn.net/wtz1985

The so-called "Lock" is to allow yourself to occupy space alone and prevent others from occupying their own resources before they are used up. the current operating system, whether it is windows, UNIX, and other operating systems. all adopt multi-threaded environments. this greatly increases the execution speed of tasks and does not affect the execution of other transactions. however, their execution depends on the rotation of time slices. If a thread is not finished, its time slice is used up and will be mounted until it is its next time slice. if we keep them so free and execute commands without constraints, it will lead to an unpredictable result. How can we solve this problem? See the following:

The reason for the lock is that a thread occupies its own resources when operating a transaction, and makes itself deduplicated. Before unlocking the lock, others can only wait, this effectively controls the way threads do not get unimaginable results due to time slice. the following code describes how the lock is implemented:

1. Interface for defining locks.

1. /* ----- Locker. h -------*/
3. # Ifndef _ locker_h
4. # DEFINE _ locker_h
6. Struct _ locker;
7. Typedef struct _ locker;
9. Typedef int (* lockerlockfunc) (locker * thiz );
10. Typedef int (* lockerunlockfunc) (locker * thiz );
11. Typedef void (* lockerdestroyfunc) (locker * thiz );
13. Struct _ locker
14. {
15. Lockerlockfunc lock;
16. Lockerunlockfunc unlock;
17. Lockerdestroyfunc locker_destroy;
19. Char priv [0];
20. };
22. Static inline int locker_lock (locker * thiz)
23. {
24. Assert (thiz! = NULL & thiz-> lock! = NULL );
26. Return thiz-> lock;
27. }
29. Static inline int locker_unlock (locker * thiz)
30. {
31. Assert (thiz! = NULL & thiz-> unlock! = NULL );
33. Return thiz-> unlock;
34. }
36. Static inline void locker_destroy (locker * thiz)
37. {
38. Assert (thiz! = NULL & thiz-> locker_destroy! = NULL );
40. Return thiz-> destroy_locker;
41. }
42. # Endif/* _ locker_h */

2. Interface for defining thread locks.

1. /* ------ Pthread_locker.h --------*/
3. # Ifndef _ pthread_locker_h
4. # DEFINE _ pthread_locker_h
6. # Include "locker. H"
8. Locker * locker_create (const char * Name );
10. # Endif/* _ pthread_locker_h */

3. Interface implementation.

1. /* ----- Pthread_locker.c ------*/
3. # Include "pthread_locker.h"
4. # Include <stdio. h>
5. # Include <stdlib. h>
6. # Include <string. h>
7. # Include <assert. h>
9. Typedef struct _ privinfo
10. {
11. Char * str_name;
12. Pthread_mutex_t mutex;
13. } Privinfo;
15. Static pthread_locker_lock (locker * thiz)
16. {
17. Assert (thiz! = NULL );
19. Privinfo * priv = (privinfo *) thiz-> priv;
20. Return pthread_mutex_lock (& (priv-> mutex ));
21. }
23. Static pthread_locker_unlock (locker * thiz)
24. {
25. Assert (thiz! = NULL );
27. Privinfo * priv = (privinfo *) thiz-> priv;
28. Return pthread_mutex_unlock (& (priv-> mutex ));
29. }
31. Static pthread_locker_destroy (locker * thiz)
32. {
33. Assert (thiz! = NULL );
35. Privinfo * priv = (privinfo *) thiz-> priv;
36. Free (priv-> Str );
37. Pthread_mutex_destroy (& (priv-> mutex ));
38. Free (thiz );
40. Return;
41. }
43. Locker * locker_create (const char * name)
44. {
45. Locker * thiz = (locker *) malloc (sizeof (locker) + sizeof (privinfo ));
46. Privinfo * priv = thiz-> priv;
47. Priv-> str_name = strdup (name );
48. Pthread_mutex_init (& (priv-> mutex), null );
50. Thiz-> lock = pthread_locker_lock;
51. Thiz-> unlock = pthread_lokcer_unlock;
52. Thiz-> locker_destroy = pthread_locker_destroy;
54. Return thiz;
55. }

This is a simple implementation of the thread lock. But when you insert data in the linked list, you need to perform the search operation. This is only a simple thread lock that cannot be solved. How can this problem be solved? This involves the issue of recursive locks. The next article describes the implementation of recursive locks.