POSIX 条件变量详细解析
2014-11-03 17:20
176 查看
条件锁pthread_cond_t
说明,
等待线程
1。使用pthread_cond_wait前要先加锁
2。pthread_cond_wait内部会解锁,然后等待条件变量被其它线程激活
3。pthread_cond_wait被激活后会再自动加锁
激活线程:
1。加锁(和等待线程用同一个锁)
2。pthread_cond_signal发送信号
3。解锁
激活线程的上面三个操作在运行时间上都在等待线程的pthread_cond_wait函数内部。
程序示例:
[cpp] view
plaincopyprint?
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
pthread_mutex_t count_lock;
pthread_cond_t count_nonzero;
unsigned count = 0;
void *decrement_count(void *arg)
{
pthread_mutex_lock(&count_lock);
printf("decrement_count get count_lock\n");
while(count == 0)
{
printf("decrement_count count == 0 \n");
printf("decrement_count before cond_wait \n");
pthread_cond_wait(&count_nonzero, &count_lock);
printf("decrement_count after cond_wait \n");
printf("decrement_count count = %d \n",count);
}
count = count + 1;
pthread_mutex_unlock(&count_lock);
}
void *increment_count(void *arg)
{
pthread_mutex_lock(&count_lock);
printf("increment_count get count_lock \n");
if(count == 0)
{
printf("increment_count before cond_signal \n");
pthread_cond_signal(&count_nonzero);
printf("increment_count after cond_signal \n");
}
count = count + 1;
printf("huangcheng \n");
printf("increment_count count = %d \n",count);
pthread_mutex_unlock(&count_lock);
}
int main(void)
{
pthread_t tid1, tid2;
pthread_mutex_init(&count_lock, NULL);
pthread_cond_init(&count_nonzero, NULL);
pthread_create(&tid1, NULL, decrement_count, NULL);
sleep(2);
pthread_create(&tid2, NULL, increment_count, NULL);
sleep(10);
pthread_exit(0);
return 0;
}
运行结果:
# gcc -o pthread_cond pthread_cond.c -lpthread
#./pthread_cond
decrement_count get count_lock
decrement_count count == 0
decrement_count before cond_wait
increment_count get count_lock
increment_count before cond_signal
increment_count after cond_signal
huangcheng
increment_count count = 1
decrement_count after cond_wait
decrement_count count = 1
多线程编程,条件变量pthread_cond_t应用
程序代码:
[cpp] view
plaincopyprint?
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
pthread_mutex_t counter_lock;
pthread_cond_t counter_nonzero;
int counter = 0;
int estatus = -1;
void *decrement_counter(void *argv);
void *increment_counter(void *argv);
int main(int argc, char **argv)
{
printf("counter: %d/n", counter);
pthread_t thd1, thd2;
int ret;
ret = pthread_create(&thd1, NULL, decrement_counter, NULL);
if(ret){
perror("del:/n");
return 1;
}
ret = pthread_create(&thd2, NULL, increment_counter, NULL);
if(ret){
perror("inc: /n");
return 1;
}
int counter = 0;
while(counter != 10){
printf("counter: %d/n", counter);
sleep(1);
counter++;
}
return 0;
}
void *decrement_counter(void *argv)
{
pthread_mutex_lock(&counter_lock);
while(counter == 0)
pthread_cond_wait(&counter_nonzero, &counter_lock);
counter--;
pthread_mutex_unlock(&counter_lock);
return &estatus;
}
void *increment_counter(void *argv)
{
pthread_mutex_lock(&counter_lock);
if(counter == 0)
pthread_cond_signal(&counter_nonzero);
counter++;
pthread_mutex_unlock(&counter_lock);
return &estatus;
}
运行结果:
#gcc -o pthread_cond2 pthread_cond2.c -lpthread
#./pthread_cond2
counter: 0
counter: 0
counter: 1
counter: 2
counter: 3
counter: 4
counter: 5
counter: 6
counter: 7
counter: 8
counter: 9
调试程序的运行过程:
1、开始时 counter 为0 (main)
2、ret = pthread_create(&thrd1, NULL, decrement_counter, NULL)处生成一个thrd1线程运行decrement_counter(),
此线程内函数运行流程为:
先锁定 互斥锁(count_lock) 如果counter为0,此线程被阻塞在条件变量(count_nonzero)上.同时释放互斥锁count_lock(wait内部会先释放锁,等待signal激活后自动再加上锁).
3、与此同时主程序还在运行,创建另一个线程thrd2运行 increment_counter,
此线程内的函数流程如下:
先锁定 互斥锁(count_lock)【wait内部释放锁的互斥锁】 如果counter为0, 唤醒在条件变量(count_nonzero)上的线程即thrd1.但是由于有互斥锁count_lock【signal激活后,wait内部又自动加上锁了】,
thrd1还是在等待. 然后count++,释放互斥锁,.......thrd1由于互斥锁释放,重新判断counter是不是为0,如果为0再把线程阻塞在条件变量count_nonzero上,但这时counter已经为1了.所以线程继续运行.counter--释放互斥锁......(退出后,运行主线程main)
4、与此主程序间隔打印counter运行一段时间退出.
注:更清晰的运行流程请详见如下“改进代码”
后记,在编译的时候加上 -lpthread
改进代码:
[cpp] view
plaincopyprint?
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
pthread_mutex_t counter_lock;
pthread_cond_t counter_nonzero;
int counter = 0;
int estatus = -1;
void *decrement_counter(void *argv);
void *increment_counter(void *argv);
int main(int argc, char **argv)
{
printf("counter: %d/n", counter);
pthread_t thd1, thd2;
int ret;
ret = pthread_create(&thd1, NULL, decrement_counter, NULL);
if(ret){
perror("del:/n");
return 1;
}
ret = pthread_create(&thd2, NULL, increment_counter, NULL);
if(ret){
perror("inc: /n");
return 1;
}
int counter = 0;
while(counter != 10){
printf("counter(main): %d/n", counter);
sleep(1);
counter++;
}
return 0;
}
void *decrement_counter(void *argv)
{
printf("counter(decrement): %d/n", counter);
pthread_mutex_lock(&counter_lock);
while(counter == 0)
pthread_cond_wait(&counter_nonzero, &counter_lock); //进入阻塞(wait),等待激活(signal)
printf("counter--(before): %d/n", counter);
counter--; //等待signal激活后再执行
printf("counter--(after): %d/n", counter);
pthread_mutex_unlock(&counter_lock);
return &estatus;
}
void *increment_counter(void *argv)
{
printf("counter(increment): %d/n", counter);
pthread_mutex_lock(&counter_lock);
if(counter == 0)
pthread_cond_signal(&counter_nonzero); //激活(signal)阻塞(wait)的线程(先执行完signal线程,然后再执行wait线程)
printf("counter++(before): %d/n", counter);
counter++;
printf("counter++(after): %d/n", counter);
pthread_mutex_unlock(&counter_lock);
return &estatus;
}
运行结果:
# gcc -o pthread_cond2 pthread_cond2.c -lpthread
#./pthread_cond2
counter: 0
counter(main): 0
counter(decrement): 0
counter(increment): 0
counter++(before): 0
counter++(after): 1
counter--(before): 1
counter--(after): 0
counter(main): 1
counter(main): 2
counter(main): 3
counter(main): 4
counter(main): 5
counter(main): 6
counter(main): 7
counter(main): 8
counter(main): 9
本文转自:/article/1753803.html
说明,
等待线程
1。使用pthread_cond_wait前要先加锁
2。pthread_cond_wait内部会解锁,然后等待条件变量被其它线程激活
3。pthread_cond_wait被激活后会再自动加锁
激活线程:
1。加锁(和等待线程用同一个锁)
2。pthread_cond_signal发送信号
3。解锁
激活线程的上面三个操作在运行时间上都在等待线程的pthread_cond_wait函数内部。
程序示例:
[cpp] view
plaincopyprint?
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
pthread_mutex_t count_lock;
pthread_cond_t count_nonzero;
unsigned count = 0;
void *decrement_count(void *arg)
{
pthread_mutex_lock(&count_lock);
printf("decrement_count get count_lock\n");
while(count == 0)
{
printf("decrement_count count == 0 \n");
printf("decrement_count before cond_wait \n");
pthread_cond_wait(&count_nonzero, &count_lock);
printf("decrement_count after cond_wait \n");
printf("decrement_count count = %d \n",count);
}
count = count + 1;
pthread_mutex_unlock(&count_lock);
}
void *increment_count(void *arg)
{
pthread_mutex_lock(&count_lock);
printf("increment_count get count_lock \n");
if(count == 0)
{
printf("increment_count before cond_signal \n");
pthread_cond_signal(&count_nonzero);
printf("increment_count after cond_signal \n");
}
count = count + 1;
printf("huangcheng \n");
printf("increment_count count = %d \n",count);
pthread_mutex_unlock(&count_lock);
}
int main(void)
{
pthread_t tid1, tid2;
pthread_mutex_init(&count_lock, NULL);
pthread_cond_init(&count_nonzero, NULL);
pthread_create(&tid1, NULL, decrement_count, NULL);
sleep(2);
pthread_create(&tid2, NULL, increment_count, NULL);
sleep(10);
pthread_exit(0);
return 0;
}
运行结果:
# gcc -o pthread_cond pthread_cond.c -lpthread
#./pthread_cond
decrement_count get count_lock
decrement_count count == 0
decrement_count before cond_wait
increment_count get count_lock
increment_count before cond_signal
increment_count after cond_signal
huangcheng
increment_count count = 1
decrement_count after cond_wait
decrement_count count = 1
多线程编程,条件变量pthread_cond_t应用
程序代码:
[cpp] view
plaincopyprint?
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
pthread_mutex_t counter_lock;
pthread_cond_t counter_nonzero;
int counter = 0;
int estatus = -1;
void *decrement_counter(void *argv);
void *increment_counter(void *argv);
int main(int argc, char **argv)
{
printf("counter: %d/n", counter);
pthread_t thd1, thd2;
int ret;
ret = pthread_create(&thd1, NULL, decrement_counter, NULL);
if(ret){
perror("del:/n");
return 1;
}
ret = pthread_create(&thd2, NULL, increment_counter, NULL);
if(ret){
perror("inc: /n");
return 1;
}
int counter = 0;
while(counter != 10){
printf("counter: %d/n", counter);
sleep(1);
counter++;
}
return 0;
}
void *decrement_counter(void *argv)
{
pthread_mutex_lock(&counter_lock);
while(counter == 0)
pthread_cond_wait(&counter_nonzero, &counter_lock);
counter--;
pthread_mutex_unlock(&counter_lock);
return &estatus;
}
void *increment_counter(void *argv)
{
pthread_mutex_lock(&counter_lock);
if(counter == 0)
pthread_cond_signal(&counter_nonzero);
counter++;
pthread_mutex_unlock(&counter_lock);
return &estatus;
}
运行结果:
#gcc -o pthread_cond2 pthread_cond2.c -lpthread
#./pthread_cond2
counter: 0
counter: 0
counter: 1
counter: 2
counter: 3
counter: 4
counter: 5
counter: 6
counter: 7
counter: 8
counter: 9
调试程序的运行过程:
1、开始时 counter 为0 (main)
2、ret = pthread_create(&thrd1, NULL, decrement_counter, NULL)处生成一个thrd1线程运行decrement_counter(),
此线程内函数运行流程为:
先锁定 互斥锁(count_lock) 如果counter为0,此线程被阻塞在条件变量(count_nonzero)上.同时释放互斥锁count_lock(wait内部会先释放锁,等待signal激活后自动再加上锁).
3、与此同时主程序还在运行,创建另一个线程thrd2运行 increment_counter,
此线程内的函数流程如下:
先锁定 互斥锁(count_lock)【wait内部释放锁的互斥锁】 如果counter为0, 唤醒在条件变量(count_nonzero)上的线程即thrd1.但是由于有互斥锁count_lock【signal激活后,wait内部又自动加上锁了】,
thrd1还是在等待. 然后count++,释放互斥锁,.......thrd1由于互斥锁释放,重新判断counter是不是为0,如果为0再把线程阻塞在条件变量count_nonzero上,但这时counter已经为1了.所以线程继续运行.counter--释放互斥锁......(退出后,运行主线程main)
4、与此主程序间隔打印counter运行一段时间退出.
注:更清晰的运行流程请详见如下“改进代码”
后记,在编译的时候加上 -lpthread
改进代码:
[cpp] view
plaincopyprint?
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
pthread_mutex_t counter_lock;
pthread_cond_t counter_nonzero;
int counter = 0;
int estatus = -1;
void *decrement_counter(void *argv);
void *increment_counter(void *argv);
int main(int argc, char **argv)
{
printf("counter: %d/n", counter);
pthread_t thd1, thd2;
int ret;
ret = pthread_create(&thd1, NULL, decrement_counter, NULL);
if(ret){
perror("del:/n");
return 1;
}
ret = pthread_create(&thd2, NULL, increment_counter, NULL);
if(ret){
perror("inc: /n");
return 1;
}
int counter = 0;
while(counter != 10){
printf("counter(main): %d/n", counter);
sleep(1);
counter++;
}
return 0;
}
void *decrement_counter(void *argv)
{
printf("counter(decrement): %d/n", counter);
pthread_mutex_lock(&counter_lock);
while(counter == 0)
pthread_cond_wait(&counter_nonzero, &counter_lock); //进入阻塞(wait),等待激活(signal)
printf("counter--(before): %d/n", counter);
counter--; //等待signal激活后再执行
printf("counter--(after): %d/n", counter);
pthread_mutex_unlock(&counter_lock);
return &estatus;
}
void *increment_counter(void *argv)
{
printf("counter(increment): %d/n", counter);
pthread_mutex_lock(&counter_lock);
if(counter == 0)
pthread_cond_signal(&counter_nonzero); //激活(signal)阻塞(wait)的线程(先执行完signal线程,然后再执行wait线程)
printf("counter++(before): %d/n", counter);
counter++;
printf("counter++(after): %d/n", counter);
pthread_mutex_unlock(&counter_lock);
return &estatus;
}
运行结果:
# gcc -o pthread_cond2 pthread_cond2.c -lpthread
#./pthread_cond2
counter: 0
counter(main): 0
counter(decrement): 0
counter(increment): 0
counter++(before): 0
counter++(after): 1
counter--(before): 1
counter--(after): 0
counter(main): 1
counter(main): 2
counter(main): 3
counter(main): 4
counter(main): 5
counter(main): 6
counter(main): 7
counter(main): 8
counter(main): 9
本文转自:/article/1753803.html
相关文章推荐
- POSIX 条件变量详细解析
- POSIX 条件变量详细解析
- POSIX 条件变量详细解析
- Linux多线程编程详细解析----条件变量 pthread_cond_t
- Linux多线程编程详细解析----条件变量 pthread_cond_t
- 转载_Linux多线程编程详细解析----条件变量 pthread_cond_t
- Linux多线程编程详细解析----条件变量 pthread_cond_t
- Linux操作系统下的多线程编程详细解析----条件变量pthread_cond_t
- Linux多线程编程详细解析----条件变量 pthread_cond_t
- Linux多线程编程详细解析----条件变量 pthread_cond_t
- Linux多线程编程详细解析----条件变量 pthread_cond_t
- Linux多线程编程详细解析----条件变量 pthread_cond_t
- Linux操作系统下的多线程编程详细解析----条件变量
- Linux操作系统下的多线程编程详细解析----条件变量
- Linux操作系统下的多线程编程详细解析----条件变量pthread_cond_t那些事儿
- pthread多线程编程详细解析----条件变量 pthread_cond_t
- Linux多线程 编程详细解析----条件变量 pthread_cond_t
- Linux操作系统下的多线程编程详细解析----条件变量pthread_cond_t那些事儿
- Linux操作系统下的多线程编程详细解析----条件变量
- pthread多线程编程详细解析----条件变量 pthread_mutex_t