Linux programming exercises-multithreading 3-mutex

Mutex refers to mutually exclusive locks. It is a semaphores that are often used to prevent two processes or threads from accessing the same shared resources at the same time.

1. Data Type:

In Linux, the thread mutex data type is pthread_mutex_t. We define a mutex data as follows:

Pthread_mutex_t mutex;

 

2. Function Description:
Header file: pthread. h

(1). mutex lock initialization:

 

Function prototype: int pthread_mutex_init (pthread_mutex_t * mutex,

Const pthread_mutexattr_t * mutexattr );
Function input value: mutex.

Mutexattr: pthread_mutex_initializer: Creates a fast mutex lock.

Pthread_recursive_mutex_initializer_np: Creates a recursive mutex lock.

Pthread_errorcheck_mutex_initializer_np: creates an error mutex lock.

Function return value: Success: 0

Error:-1
(2). mutex operation function

Int pthread_mutex_lock (pthread_mutex_t * mutex); // lock

Int pthread_mutex_trylock (pthread_mutex_t * mutex); // The lock is blocked only when the mutex is locked.

Int pthread_mutex_unlock (pthread_mutex_t * mutex); // unlock

Int pthread_mutex_destroy (pthread_mutex_t * mutex); // clear the mutex lock

Function input value: mutex.

Function return value: Success: 0

Error:-1

3. Usage:

Struct mutex;

Mutex_init (& mutex);/* definition */

...
Mutex_lock (& mutex);/* Get mutex lock */

.../* Critical resource */

Mutex_unlock (& mutex);/* release mutex lock */

 

 

Finally, let's start an exercise: We create two threads, access the global variable gnum, modify it, and print it out.

[CPP]View plaincopy

1. /* Mutex. C */
2. # Include <stdlib. h>
3. # Include <stdio. h>
4. # Include <pthread. h>
5. # Include <errno. h>
6. /* Global variable */
7. Int gnum = 0;
8. /* Mutex */
9. Pthread_mutex_t mutex;
10. /* Declare the thread to run the Service Program */
11. Static void pthread_func_1 (void );
12. Static void pthread_func_2 (void );
14. Int main (void)
15. {
16. /* Thread identifier */
17. Pthread_t pt_1 = 0;
18. Pthread_t pt_2 = 0;
19. Int ret = 0;
20. /* Mutex initialization */
21. Pthread_mutex_init (& mutex, null );
22. /* Create thread 1 and thread 2 respectively */
23. Ret = pthread_create (& pt_1, // thread ID pointer
24. Null, // default attribute
25. (Void *) pthread_func_1, // run the Function
26. Null); // No Parameter
27. If (Ret! = 0)
28. {
29. Perror ("pthread_cmdcreate ");
30. }
32. Ret = pthread_create (& pt_2, // thread identifier pointer
33. Null, // default attribute
34. (Void *) pthread_func_2, // run the Function
35. Null); // No Parameter
36. If (Ret! = 0)
37. {
38. Perror ("pthread_2_create ");
39. }
40. /* Wait for the end of thread 1 and thread 2 */
41. Pthread_join (pt_1, null );
42. Pthread_join (pt_2, null );
44. Printf ("main programme exit! /N ");
45. Return 0;
46. }
47. /* Service program of thread 1 */
48. Static void pthread_func_1 (void)
49. {
50. Int I = 0;
52. For (;;)
53. {
54. Printf ("this is pthread1! /N ");
55. Pthread_mutex_lock (& mutex);/* obtain the mutex lock */
56. /* Note: This is to prevent the thread from being preemptible, so that a thread can access mutex resources multiple times during another thread sleep. Therefore, sleep must be called after obtaining the mutex lock */
57. Sleep (1 );
58. /* Critical resources */
59. Gnum ++;
60. Printf ("thread1 add one to num: % d/N", gnum );
61. Pthread_mutex_unlock (& mutex);/* release mutex lock */
64. }
65. }
66. /* Service program of thread 2 */
67. Static void pthread_func_2 (void)
68. {
69. Int I = 0;
71. For (;;)
72. {
73. Printf ("this is pthread2! /N ");
74. Pthread_mutex_lock (& mutex);/* obtain the mutex lock */
75. /* Note: This is to prevent the thread from being preemptible, so that a thread can access mutex resources multiple times during another thread sleep. Therefore, sleep must be called after obtaining the mutex lock */
76. Sleep (1 );
77. /* Critical resources */
78. Gnum ++;
79. Printf ("thread2 add one to num: % d/N", gnum );
80. Pthread_mutex_unlock (& mutex);/* release mutex lock */
82. }
84. Pthread_exit (0 );
85. }

Then compile and run the program. We can see that the thread 1 and 2 access the shared resources in a peaceful way.