linux网络编程之posix 线程（四）：posix 条件变量与互斥锁 示例生产者--消费者问题

http://blog.csdn.net/jnu_simba/article/details/9129939

一、posix 条件变量

一种线程间同步的情形：线程A需要等某个条件成立才能继续往下执行，现在这个条件不成立，线程A就阻塞等待，而线程B在执行过程中使这个条件成立了，就唤醒线程A继续执行。


在pthread库中通过条件变量（Condition Variable）来阻塞等待一个条件，或者唤醒等待这个条件的线程。Condition Variable用pthread_cond_t类型的变量表示，和Mutex的初始化和销毁类似，pthread_cond_init函数初始化一个Condition Variable，attr参数为NULL则表示缺省属性，pthread_cond_destroy函数销毁一个Condition Variable。如果ConditionVariable是静态分配的，也可以用宏定义PTHEAD_COND_INITIALIZER初始化，相当于用pthread_cond_init函数初始化并且attr参数为NULL。


一个Condition Variable总是和一个Mutex搭配使用的。一个线程可以调用pthread_cond_wait在一个Condition Variable上阻塞等待，这个函数做以下三步操作：
1. 释放Mutex
2. 阻塞等待
3. 当被唤醒时，重新获得Mutex并返回

注意：3个操作是原子性的操作，之所以一开始要释放Mutex，是因为需要让其他线程进入临界区去更改条件，或者也有其他线程需要进入临界区等待条件。


一个线程可以调用 pthread_cond_signal 唤醒在某个Condition Variable上等待的第一个线程，也可以调用 pthread_cond_broadcast 唤醒在这个Condition Variable上等待的所有线程。


上面的函数具体可以man 一下。


二、条件变量使用规范

（一）、等待条件代码
pthread_mutex_lock(&mutex);

while (条件为假）

pthread_cond_wait(cond, mutex);

修改条件
pthread_mutex_unlock(&mutex);


（二）、给条件发送通知代码
pthread_mutex_lock(&mutex);
设置条件为真
pthread_cond_signal(cond);
pthread_mutex_unlock(&mutex);


假设第一段用于消费者线程，第二段用于生产者线程。为什么消费者线程要用while 而不是if 就可以呢？在man pthread_cond_wait 有一句：If a signal is delivered to a thread waiting for a condition variable, upon return from the signal handler the thread resumes waiting for the condition variable as if it was not interrupted, or it shall return zero due to spurious wakeup.

即是说如果正在等待条件变量的一个线程收到一个信号，从信号处理函数返回的时候线程应该重新等待条件变量就好象没有被中断一样，或者被虚假地唤醒返回0。如果是上述情形，那么其实条件并未被改变，那么此时如果没有继续判断一下条件的真假就继续向下执行的话，修改条件将会出现问题，所以需要使用while 循环再判断一下，如果条件还是为假必须继续等待。

注：在多处理器系统中，pthread_cond_signal 可能会唤醒多个等待条件的线程，这也是一种spurious wakeup。


当生产者线程较多，即生产得比较快，在这边假设是无界的缓冲区（比如链表），可以不停地生产，使用pthread_cond_signal  发出通知的时候，如果此时没有消费者线程在等待条件，那么这个通知将被丢弃，但也不影响整体代码的执行，没有消费者线程在等待，说明产品资源充足，即while 判断失败，不会进入等待状态，直接消费产品（即修改条件）。


三、生产者消费者问题 

C++ Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
#include <unistd.h>
#include <sys/types.h>
#include <pthread.h>
#include <semaphore.h>

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>

#define ERR_EXIT(m) \
        do \
        { \
                perror(m); \
                exit(EXIT_FAILURE); \
        } while(0)

#define CONSUMERS_COUNT 2
#define PRODUCERS_COUNT 1

pthread_mutex_t g_mutex;
pthread_cond_t g_cond;

pthread_t g_thread[CONSUMERS_COUNT + PRODUCERS_COUNT];

int nready = 0;

void *consume(void *arg)
{
    int num = (int)arg;
    while (1)
    {
        pthread_mutex_lock(&g_mutex);
        while (nready == 0)
        {
            printf("%d begin wait a condtion ...\n", num);
            pthread_cond_wait(&g_cond, &g_mutex);
        }

        printf("%d end wait a condtion ...\n", num);
        printf("%d begin consume product ...\n", num);
        --nready;
        printf("%d end consume product ...\n", num);
        pthread_mutex_unlock(&g_mutex);
        sleep(1);
    }
    return NULL;
}

void *produce(void *arg)
{
    int num = (int)arg;
    while (1)
    {
        pthread_mutex_lock(&g_mutex);
        printf("%d begin produce product ...\n", num);
        ++nready;
        printf("%d end produce product ...\n", num);
        pthread_cond_signal(&g_cond);
        printf("%d signal ...\n", num);
        pthread_mutex_unlock(&g_mutex);
        sleep(1);
    }
    return NULL;
}

int main(void)
{
    int i;

    pthread_mutex_init(&g_mutex, NULL);
    pthread_cond_init(&g_cond, NULL);


    for (i = 0; i < CONSUMERS_COUNT; i++)
        pthread_create(&g_thread[i], NULL, consume, (void *)i);

    sleep(1);

    for (i = 0; i < PRODUCERS_COUNT; i++)
        pthread_create(&g_thread[CONSUMERS_COUNT + i], NULL, produce, (void *)i);

    for (i = 0; i < CONSUMERS_COUNT + PRODUCERS_COUNT; i++)
        pthread_join(g_thread[i], NULL);

    pthread_mutex_destroy(&g_mutex);
    pthread_cond_destroy(&g_cond);

    return 0;
}


在上面程序中，++nready 就当作是生产产品了，--nready就当作是消费产品了，跟前面文章所不同的是，这里没有缓冲区大小的概念，可以当作是无界缓冲区，生产者可以一直生产，但消费者只有当有产品的时候才能消费，否则就得等待，等待结束的条件就是nready > 0；上面也说过当生产得比较快（生产者线程多）的时候，也有可能消费者线程一直不存在等待的状态，因为nready 的值很大，即产品资源很多。现在设置的是2个消费者线程和1个生产者线程，所以动态输出来看一般是2个消费者线程轮流等待。


参考：

《linux c 编程一站式学习》

《UNP》


本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/383916.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

3-V2-类和对象 -- const内联 静态成员 友元

3-V2-类和对象 -- const内联 静态成员 友元

const修饰成员函数 在成员函数后面加一个const, const修饰this指针指向的对象, 保证调用这个const成员函数的对象在函数内不会被改变 注意:成员函数如果不修改成员变量,则加上const,成员函数如果要修改成员变量,此时就不能给其加上const修饰了 1.const对象不能调用非const…
阅读更多...
C语言 二级指针内存模型混合实战

C语言 二级指针内存模型混合实战

http://www.cnblogs.com/zhanggaofeng/p/5485833.html //二级指针内存模型混合实战 #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <stdlib.h> #include <string.h>//将内存模型①和内存模型②的数据拷贝到内存模型③ char ** threemodel(ch…
阅读更多...
扩展欧几里得算法

扩展欧几里得算法

对于a∗xb∗yca*xb*yca∗xb∗yc,这样一个二元一次方程组&#xff0c;我们想要得到他的一组解可以用扩展欧几里得算法&#xff0c;参数列表的a,b,x,y就是方程中的a,b,x,y&#xff0c;d计算出来是gcd(a,b)。 算法求出来的是a∗xb∗ygcd(a,ba*xb*ygcd(a,ba∗xb∗ygcd(a,b的一组解…
阅读更多...
Linux 网络编程八（epoll应用--大并发处理）

Linux 网络编程八（epoll应用--大并发处理）

http://www.cnblogs.com/zhanggaofeng/p/5901316.html //头文件 pub.h #ifndef _vsucess#define _vsucess#ifdef __cplusplus extern "C" {#endif //服务器创建socket int server_socket(int port);//设置非阻塞 int setnonblock(int st);//接收客户端socket int ser…
阅读更多...
约瑟夫问题

约瑟夫问题

n个人编号为0…n-1围成一个圈,从0开始报数,每经过k个人那个人就退出这个圈不再报数,问最后留下来的人的编号. 朴素的做法当然是模拟,但是n,k的值一旦变得比较大的时候就难以解决问题. 我们考虑归纳的解决问题 当只有一个人的时候答案显然为0, 假设我们已知n-1个人的时候答案为…
阅读更多...
【数据结构与算法】内部排序之三：堆排序（含完整源码）

【数据结构与算法】内部排序之三：堆排序（含完整源码）

转载请注明出处&#xff1a;http://blog.csdn.net/ns_code/article/details/20227303 前言 堆排序、快速排序、归并排序&#xff08;下篇会写这两种排序算法&#xff09;的平均时间复杂度都为O&#xff08;n*logn&#xff09;。要弄清楚堆排序&#xff0c;就要先了解下二叉堆这…
阅读更多...
模线性方程(中国剩余定理+扩展中国剩余定理)

模线性方程(中国剩余定理+扩展中国剩余定理)

已知一系列除数和模数,求最小的满足条件的数 我们先考虑一般的情况&#xff0c;即模数不互质。&#xff08;扩展中国剩余定理&#xff09; 我们考虑两个方程的情况 x%MR xk1∗MRxk1 * MRxk1∗MR x%mr xk2∗mrxk2 * mrxk2∗mr 所以k1∗MRk2∗mrk1 * MRk2 * mrk1∗MRk2∗mr 即…
阅读更多...
C++:Vector和List的实现

C++:Vector和List的实现

Vector的实现 //test.h #pragma once#include <iostream> #include <cstdio> #include <string.h> #include <assert.h>using namespace std;typedef int DataType;#define TESTHEADER printf("\n%s\n", __FUNCTION__)class Vector { publi…
阅读更多...
【数据结构】（面试题）使用两个栈实现一个队列(详细介绍)

【数据结构】（面试题）使用两个栈实现一个队列(详细介绍)

http://blog.csdn.net/hanjing_1995/article/details/51539578 使用两个栈实现一个队列 思路一&#xff1a; 我们设定s1是入栈的&#xff0c;s2是出栈的。 入队列&#xff0c;直接压到s1即可 出队列&#xff0c;先把s1中的元素倒入到s2中&#xff0c;弹出s2中的栈顶元素&#x…
阅读更多...
POJ 1006 Biorhythms

POJ 1006 Biorhythms

中国剩余定理的模板题 只是有一个问题就是求出来Xk*MR中的R比给定的日期还大&#xff0c;但是如果负数的整除就不是向下取整了&#xff0c;为了解决这个问题&#xff0c;我们将R减小M&#xff0c;这样总是正的&#xff0c;求出来的就没有什么问题。 #include <iostream>…
阅读更多...
POJ 3696 欧拉函数+快速幂

POJ 3696 欧拉函数+快速幂

题目的意思大概就是问是否存在一串全是8的数字是L的倍数 直接想没有什么想法&#xff0c;要想到用简洁的形式将这个数字表示出来&#xff0c;对于每一位都是8的数字我们可以用 X8*(10k-1)/9的形式表示出来&#xff0c;那么题目的意思就是求X使L|X&#xff0c;我们先处理一下8和…
阅读更多...
两个栈实现一个队列，两个队列实现一个栈

两个栈实现一个队列，两个队列实现一个栈

http://blog.csdn.net/zw_1510/article/details/51927554 问题1&#xff1a;用两个栈实现一个队列&#xff0c;实现队列的push和delete操作 栈的特性是先进后出&#xff08;FILO&#xff09;,队列的特性是先进先出&#xff08;FIFO&#xff09;,在实现delete时&#xff0c;我们…
阅读更多...
C++:String的写时拷贝

C++:String的写时拷贝

String的写时拷贝 //test.h #pragma once#include <iostream> #include <string.h> #include <cstdio> #include <assert.h> using namespace std;#define TESTHEADER printf("\n%s\n", __FUNCTION__) class String { public:String(const …
阅读更多...
两个栈实现一个队列与两个队列实现一个栈

两个栈实现一个队列与两个队列实现一个栈

http://blog.csdn.net/z84616995z/article/details/19204529 两个栈实现一个队列&#xff1a; 原理方法&#xff1a;用一个栈为主栈&#xff0c;一个栈为辅助栈存放临时元素。 入队&#xff1a;将元素依次压入主栈 出队&#xff1a;先检测辅助栈是否为空&#xff0c;如果非空&a…
阅读更多...
UVa11426——欧拉函数

UVa11426——欧拉函数

发现对于gcd问题要多和欧拉函数联系在一起&#xff0c;虽然有时候并不是互质&#xff0c;但是我们知道有多少互质的然后根据互质的数目就能解决很多个gcd的问题 对于这道题目&#xff0c;题目要求的是所有数对的gcd的和&#xff0c;直接思考的话有难度。但是我们如果联想到欧拉…
阅读更多...
C++:继承和多态

C++:继承和多态

虚函数:只有类的成员函数才能定义为虚函数 虚函数 在类的成员函数前面加上一个 virtual 关键字, 此时这个成员函数就叫做虚函数 虚函数 当在子类中定义了一个与父类完全相同的虚函数的时候,此时就叫做子类的虚函数重写了父类的虚函数 构成多态的条件 派生类重写基类的虚函数…
阅读更多...
POJ 1061扩展欧几里得

POJ 1061扩展欧几里得

扩展欧几里得的模板题&#xff0c;需要注意的是为了得到一个最小正数解我们要使axbyc中的a,b都是正数 #include<cstdio> #include<cstring> #include<cstdlib> #include<algorithm> #include<iostream> #include<cmath> #include<ctim…
阅读更多...
C++::探索对象模型

C++::探索对象模型

前面我们已经知道, 在没有虚函数的时候, 对象的大小就是对应的成员变量的大小, 而成员函数不会占用对象的空间, 今天我们来讨论一下, 当类中定义了虚函数的时候, 此时对象的大小以及对象模型 非继承下的对象模型 class Base { public:virtual void func1(){cout << &qu…
阅读更多...
auto_ptr

auto_ptr

#include <iostream> #include <memory> using namespace std;class A { public:A(){cout<<"构造"<<endl;}~A(){cout<<"A析构"<<endl;}void fun(){cout<<"A::fun"<<endl;} };class PA { public…
阅读更多...
POJ 2142——扩展欧几里得

POJ 2142——扩展欧几里得

题目是很裸的扩展欧几里得&#xff0c;但是对x,y有限制条件&#xff0c;要求所有x,y中abs(x)abs(y)最小&#xff0c;在这个条件下要求abs(a* x)abs(b* y)最小 显然我们需要用扩展欧几里得求得一组解&#xff0c;问题在于如何处理这组解以得到符合条件的值。 我是这样处理的&a…
阅读更多...
最新文章

Copyright @ 2022~2023