linux网络编程，进程间的通信之互斥锁与条件变量

来源：互联网发布：搜狗搜索sem优化师编辑：程序博客网时间：2024/06/06 09:07

互斥锁mutex

1#include<stdio.h>

2 #include<unistd.h>
3 #include<pthread.h>
4 /*互斥锁函数
5 * pthread_mutex_t*
6 * pthread_mutex_init()*
7 * pthread_mutex_destory()*
8 * pthread_mutex_lock()* //阻塞，直到解锁为止才停止阻塞
9 * pthread_mutex_unlock()*//解锁
10 * pthread_mutex_try_lock()*//非阻塞函数
11 * */
12 pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
13
14 void*thread_fun1(void* arg)//函数thread_fun1
15 {
16     //printf("enter fun1\n");
17     pthread_mutex_lock(&mutex);//上锁
18     //printf("mutex fun1 lock.\n");
19     printf("1\n");
20     printf("fun1 sleep...\n");
21     sleep(12);
22
23     printf("fun1 wakeup.\n");
24     pthread_mutex_unlock(&mutex);//解锁
25     //printf("mutex fun1 unlock\n");
26 }
27 void*thread_fun2(void* arg)//函数thread_fun2
28 {
29     //printf("enter fun2\n");
30     pthread_mutex_lock(&mutex);//上锁,等待
31     //printf("mutex fun2 lock\n");
32     pthread_mutex_trylock(&mutex);// 尝试锁，为非阻塞函数，若互斥锁已锁返回EBUSY，不等待
33     //pthread_mutex_lock(&mutex);
34     //printf("mutex fun2 trylock.\n");
35     printf("2\n");
36     pthread_mutex_unlock(&mutex);//解锁
37     //printf("mutex fun2 unlock\n");
38
39 }
40 int main()
41 {
42     pthread_t tid1,tid2;
43     pthread_create(&tid1, NULL, thread_fun1, NULL);// 启动线程tid1，每个线程执行thread_fun1,在tid1中保存每个线程的线程地址
44
45     pthread_create(&tid2, NULL, thread_fun2, NULL);// 启动线程tid2，每个线程执行thread_fun2,在tid2中保存每个线程的线程地址
46
47     pthread_join(tid1, NULL);//等待终止线程
48     pthread_join(tid2, NULL);//等待终止线程

互斥锁用于上锁，条件变量用于等待

条件变量cond

1 #include<stdio.h>
2 #include<unistd.h>
3 #include<pthread.h>
4 /*
5 *pthread_cond_t*
6 *pthread_cond_init()*
7 *pthread_cond_destory()*
8 *pthread_cond_wait()//一直等待，为等待+减锁，一直等待下去
9 *pthread_cond_timedwait()//定时等待，允许线程就阻塞时间设置一个限制值
10 *pthread_cond_signal()//为加锁+ 不等待，直接加锁，唤醒，谁先阻塞，只唤醒谁，只唤醒等待在相应条件变量上的一个
线程但需避免重复加锁

11 *pthread_cond_broadcast()// 唤醒所有阻塞在相应条件变量上的所有进程，一下子全部唤醒
12 * */
13

14 pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
15 pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
16
17 void* thread_fun1(void *arg)
18 {
19     printf("enter fun1\n");
20     pthread_mutex_lock(&mutex);
21
22     printf("This is fun1.\n");
23     printf("fun1 sleep...\n");
24     sleep(12);
25     //pthread_cond_wait(&cond, &mutex);
26     pthread_cond_timedwait(&cond, &mutex);
27     printf("fun1 wakeup.\n");
28     pthread_mutex_unlock(&mutex);
29     printf("fun1 unlock.\n");
30 }

31 void* thread_fun2(void *arg)
32 {
33     printf("enter fun2\n");
34     //pthread_mutex_lock(&mutex);
35     //printf("fun2 lock.\n");
36
37     printf("This is fun2.\n");
38     //printf("fun1 sleep........\n");
39     //sleep(2);
40     pthread_cond_signal(&cond);
41     //printf("fun2 sleep....\n");
42     sleep(15);
43     pthread_mutex_unlock(&mutex);
44     printf("fun2 unlock\n");
45 }
46
47 int main()
48 {
49     pthread_t tid1,tid2;
50     pthread_create(&tid1, NULL, thread_fun1, NULL);
51     pthread_create(&tid2, NULL, thread_fun2, NULL);
52
53     pthread_join(tid1, NULL);
54     pthread_join(tid2, NULL);
55     return 0;
56 }

58 #define MAX_SIZE 10
59 static int max_count = MAX_SIZE;
60 static int cur_count = 1;
61
62 pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
63 pthread_cond_t OS = PTHREAD_COND_INITIALIZER;
64 pthread_cond_t JS = PTHREAD_COND_INITIALIZER;
65
66 void* A_fun(void *arg)
67 {
68     while(cur_count <= max_count)
69     {
70         pthread_mutex_lock(&mutex);
71         if(cur_count % 2 == 1)
72         {
73             printf("A : %d\n",cur_count);
74             cur_count++;
75             pthread_cond_signal(&JS);
76         }
77         else
78         {
79             pthread_cond_wait(&OS, &mutex);
80         }
81         pthread_mutex_unlock(&mutex);
82     }
83 }
84 void* B_fun(void *arg)
85 {
86     while(cur_count <= max_count)
87     {
88         pthread_mutex_lock(&mutex);
89         if(cur_count % 2 == 0)
90         {
91             printf("B : %d\n",cur_count);
92             cur_count++;
93             pthread_cond_signal(&OS);
94         }
95         else
96             pthread_cond_wait(&JS, &mutex);
97         pthread_mutex_unlock(&mutex);
98     }
99 }
100 int main()
101 {
102     pthread_t ta_id, tb_id;
103     pthread_create(&ta_id, NULL, A_fun, NULL);
104     pthread_create(&tb_id, NULL, B_fun, NULL);
105
106     pthread_join(ta_id, NULL);
107     pthread_join(ta_id, NULL);
108     return 0;
109 }

读/写锁（读锁：共享锁；写锁：独占锁（线对写锁分配，即写锁优先），）

114 pthread_rwlock_t rwlock = PTHREAD_RWLOCK_INITIALIZER;
115 void* A_fun(void *arg)
116 {
117     pthread_rwlock_wrlock(&rwlock);
118     printf("This is A fun.\n");
119     sleep(10);
120     pthread_rwlock_unlock(&rwlock);
121 }
122 void* B_fun(void *arg)
123 {
124     pthread_rwlock_rdlock(&rwlock);
125     printf("This is B fun.\n");
126     pthread_rwlock_unlock(&rwlock);
127 }
128 void* C_fun(void *arg)
129 {
130     pthread_rwlock_wrlock(&rwlock);
131     printf("This is C fun.\n");
132     pthread_rwlock_unlock(&rwlock);
133 }
134
135 void* D_fun(void *arg)
136 {
137     pthread_rwlock_rdlock(&rwlock);
138     printf("This is D fun.\n");
139     pthread_rwlock_unlock(&rwlock);
140 }
141
142 void* E_fun(void *arg)
143 {
144      pthread_rwlock_wrlock(&rwlock);
145      printf("This is E fun.\n");
146      pthread_rwlock_unlock(&rwlock);
147 }

148 void* F_fun(void *arg)
149 {
150     pthread_rwlock_rdlock(&rwlock);
151     printf("This is F fun.\n");
152     pthread_rwlock_unlock(&rwlock);
153 }
154 int main()
155 {
156     pthread_t ta_id, tb_id, tc_id, td_id, te_id, tf_id;
157     pthread_create(&ta_id, NULL, A_fun, NULL);
158     sleep(2);
159     pthread_create(&tb_id, NULL, B_fun, NULL);
160     pthread_create(&tc_id, NULL, C_fun, NULL);
161     pthread_create(&td_id, NULL, D_fun, NULL);
162     pthread_create(&te_id, NULL, E_fun, NULL);
163     pthread_create(&tf_id, NULL, F_fun, NULL);
164
165     pthread_join(ta_id, NULL);
166     pthread_join(tb_id, NULL);
167     pthread_join(tc_id, NULL);
168     pthread_join(td_id, NULL);
169     pthread_join(te_id, NULL);
170     pthread_join(tf_id, NULL);
171 }

阅读全文

1 0