C/C ++: multi-thread programming BASICS (5)

Http://blog.csdn.net/lzx_bupt/article/details/6913151

Recently, I like to hear old songs from universities. Deutschland was popular during the World Cup in Germany. It is said that it is not a theme song, but it is more popular than the theme song.

This article introduces the difficult concept of mutex lock. mutex = mutual exclusion stands for mutex =. By the way, teachers used to love the abbreviation and did not tell the full name to their classmates, can Nima have a deep understanding! The usage is as follows:

[CPP] View plaincopy

2. # Include <iostream>
4. # Include <pthread. h> // follow the rules
8. Using NamespaceSTD;
12. # Define num_threads 5
16. IntSum = 0;// Define a global variable to allow all threads to access it. This will result in simultaneous write, and a lock mechanism is required;
18. Pthread_mutex_t sum_mutex;
22. Void* Say_hello (Void* ARGs)
24. {
26. Cout <"Hello in thread"<*((Int*) ARGs) <Endl;
28. Pthread_mutex_lock (& sum_mutex );// Modify sum to lock the lock first. When the lock is occupied, the lock is blocked until the lock is obtained and sum is modified;
30. Cout <"Before sum is"<Sum <"In thread"<*((Int*) ARGs) <Endl;
32. Sum + = *((Int*) ARGs );
34. Cout <"After sum is"<Sum <"In thread"<*((Int*) ARGs) <Endl;
36. Pthread_mutex_unlock (& sum_mutex );// Unlock after completion and release it to other threads for use;
40. Pthread_exit (0 );// Exit and throw a status code.
42. }
46. IntMain ()
48. {
50. Pthread_t tids [num_threads];
52. IntIndexes [num_threads];
54. // The next three statements are about setting thread parameters.
56. Pthread_attr_t ATTR;
58. Pthread_attr_init (& ATTR );
60. Pthread_attr_setdetachstate (& ATTR, pthread_create_joinable );
64. Pthread_mutex_init (& sum_mutex, null );// This statement is required to initialize the lock;
68. For(IntI = 0; I <num_threads; ++ I)
70. {
72. Indexes [I] = I;
74. IntRet = pthread_create (& tids [I], & ATTR, say_hello ,(Void*) & (Indexes [I]);// Modify the sum of the five processes;
76. If(Ret! = 0)
78. {
80. Cout <"Pthread_create error: error_code ="<RET <Endl;
82. }
84. }
88. Pthread_attr_destroy (& ATTR );// Delete parameter variables
92. Void* Status;
94. For(IntI = 0; I <num_threads; ++ I)
96. {
98. IntRet = pthread_join (tids [I], & status );
100. If(Ret! = 0)
102. {
104. Cout <"Pthread_join error: error_code ="<RET <Endl;
106. }
108. }
112. Cout <"Finally sum is"<Sum <Endl;
116. Pthread_mutex_destroy (& sum_mutex );// Deregister the lock. We can see that all the built-in pthread variables correspond to the destroy function. It is estimated that the memory leakage is related;
118. }

Convention: G ++-lpthread-O ex_mutex ex_mutex.cpp

Run:

[CPP] View plaincopy

2. Hello inThread4
4. Before sum is 0 inThread4
6. After sum is 4 inThread4
8. Hello inThread3
10. Before sum is 4 inThread3
12. After sum is 7 inThread3
14. Hello inThread2
16. Before sum is 7 inThread2
18. After sum is 9 inThread2
20. Hello inThread1
22. Before sum is 9 inThread1
24. After sum is 10 inThread1
26. Hello inThread0
28. Before sum is 10 inThread0
30. After sum is 10 inThread0
32. Finally sum is 10

It was found that thread4 was run first. It was strange that I increased progressively from 0, so the order of multithreading was chaotic and chaos was normal; as long as sum access and modification are normal, multithreading is achieved, and the running sequence cannot be used as a reference;