采用多生产者,多消费者模型。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/**
 * 生产者
 */
P(nempty);
P(mutex);
// 写入一个空闲位置
V(mutex);
V(nstored);
 
/**
 * 消费者
 */
P(nstored);
P(mutex):
// 清空一个非空闲位置
V(mutex);
V(nempty);

全局性说明:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include    "unpipc.h"
 
#define NBUFF        10
#define MAXNTHREADS 100
 
int     nitems, nproducers, nconsumers;     /* read-only */
 
struct      /* data shared by producers and consumers */
{
    int   buff[NBUFF];
    int   nput;           /* item number: 0, 1, 2, ... */
    int   nputval;        /* value to store in buff[] */
    int   nget;           /* item number: 0, 1, 2, ... */
    int   ngetval;        /* value fetched from buff[] */
    sem_t mutex, nempty, nstored;     /* semaphores, not pointers */
} shared;
 
void    *produce(void *);
void    *consume(void *);
/* end globals */

主函数:

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
/* include main */
int
main(int argc, char **argv)
{
    int     i, prodcount[MAXNTHREADS], conscount[MAXNTHREADS];
    pthread_t   tid_produce[MAXNTHREADS], tid_consume[MAXNTHREADS]; 
 
    if (argc != 4)
        err_quit("usage: prodcons4 <#items> <#producers> <#consumers>");
    nitems = atoi(argv[1]);
    nproducers = min(atoi(argv[2]), MAXNTHREADS);
    nconsumers = min(atoi(argv[3]), MAXNTHREADS);
 
    /* 4initialize three semaphores */
    Sem_init(&shared.mutex, 0, 1);
    Sem_init(&shared.nempty, 0, NBUFF);
    Sem_init(&shared.nstored, 0, 0);
 
    /* 4create all producers and all consumers */
    Set_concurrency(nproducers + nconsumers);
    for (i = 0; i < nproducers; i++)
    {
        prodcount[i] = 0;
        Pthread_create(&tid_produce[i], NULL, produce, &prodcount[i]);
    }
    for (i = 0; i < nconsumers; i++)
    {
        conscount[i] = 0;
        Pthread_create(&tid_consume[i], NULL, consume, &conscount[i]);
    }
 
    /* 4wait for all producers and all consumers */
    for (i = 0; i < nproducers; i++)
    {
        Pthread_join(tid_produce[i], NULL);
        printf("producer count[%d] = %d\n", i, prodcount[i]);
    }
    for (i = 0; i < nconsumers; i++)
    {
        Pthread_join(tid_consume[i], NULL);
        printf("consumer count[%d] = %d\n", i, conscount[i]);
    }
 
    Sem_destroy(&shared.mutex);
    Sem_destroy(&shared.nempty);
    Sem_destroy(&shared.nstored);
    exit(0);
}
/* end main */

生产者线程:

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
/* include produce */
void *
produce(void *arg)
{
    for ( ; ; )
    {
        Sem_wait(&shared.nempty);   /* wait for at least 1 empty slot */
        Sem_wait(&shared.mutex);
 
        if (shared.nput >= nitems)
        {
            Sem_post(&shared.nstored);  /* let consumers terminate */
            Sem_post(&shared.nempty);
            Sem_post(&shared.mutex);
            return(NULL);           /* all done */
        }
 
        shared.buff[shared.nput % NBUFF] = shared.nputval;
        shared.nput++;
        shared.nputval++;
 
        Sem_post(&shared.mutex);
        Sem_post(&shared.nstored);  /* 1 more stored item */
        *((int *) arg) += 1;
    }
}
/* end produce */

消费者线程:

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
/* include consume */
void *
consume(void *arg)
{
    int     i;
 
    for ( ; ; )
    {
        Sem_wait(&shared.nstored);  /* wait for at least 1 stored item */
        Sem_wait(&shared.mutex);
 
        if (shared.nget >= nitems)
        {
            Sem_post(&shared.nstored);
            Sem_post(&shared.mutex);
            return(NULL);           /* all done */
        }
 
        i = shared.nget % NBUFF;
        if (shared.buff[i] != shared.ngetval)
            printf("error: buff[%d] = %d\n", i, shared.buff[i]);
        shared.nget++;
        shared.ngetval++;
 
        Sem_post(&shared.mutex);
        Sem_post(&shared.nempty);   /* 1 more empty slot */
        *((int *) arg) += 1;
    }
}
/* end consume */
 

Unix IPC之Posix信号量实现生产者消费者的更多相关文章

  1. 【Windows】用信号量实现生产者-消费者模型

    线程并发的生产者-消费者模型: 1.两个进程对同一个内存资源进行操作,一个是生产者,一个是消费者. 2.生产者往共享内存资源填充数据,如果区域满,则等待消费者消费数据. 3.消费者从共享内存资源取数据 ...

  2. day34 python学习 守护进程,线程,互斥锁,信号量,生产者消费者模型,

    六 守护线程 无论是进程还是线程,都遵循:守护xxx会等待主xxx运行完毕后被销毁 需要强调的是:运行完毕并非终止运行 #1.对主进程来说,运行完毕指的是主进程代码运行完毕 #2.对主线程来说,运行完 ...

  3. Unix IPC之Posix消息队列(1)

    部分参考:http://www.cnblogs.com/Anker/archive/2013/01/04/2843832.html IPC对象的持续性:http://book.51cto.com/ar ...

  4. Unix IPC之Posix消息队列(3)

    struct mq_attr { long mq_flags; /* message queue flag : 0, O_NONBLOCK */ long mq_maxmsg; /* max numb ...

  5. Unix IPC之Posix消息队列(2)

    /* Query status and attributes of message queue MQDES. */ extern int mq_getattr (mqd_t __mqdes, stru ...

  6. 课程设计——利用信号量实现生产者-消费者问题(java)

    package cn.Douzi.ProductConsume; import java.util.LinkedList; import java.util.Queue; import java.ut ...

  7. Linux多线程实践(六)使用Posix条件变量解决生产者消费者问题

    前面的一片文章我们已经讲过使用信号量解决生产者消费者问题.那么什么情况下我们须要引入条件变量呢? 这里借用  http://www.cnblogs.com/ngnetboy/p/3521547.htm ...

  8. Operating System-进程/线程内部通信-信号量、PV操作的实现和应用(解决哲学家进餐和生产者消费者问题)

    本文主要内容: 信号量的实现 利用信号量解决哲学家用餐问题 利用信号量解决生产者消费者问题 一.信号量的实现 1.1 信号量结构 typedef struct { int value; struct ...

  9. Linux多线程实践(5) --Posix信号量与互斥量解决生产者消费者问题

    Posix信号量 Posix 信号量 有名信号量 无名信号量 sem_open sem_init sem_close sem_destroy sem_unlink sem_wait sem_post ...

随机推荐

  1. 解题:BJOI 2006 狼抓兔子

    题面 可以看出来是最小割,然后你就去求最大流了 这么大的范围就是让你用网络流卡的?咋想的啊=.=??? 建议还是老老实实用 平面图最小割等于其对偶图最短路 这个东西来做吧,虽然这个东西跑的也挺慢的,最 ...

  2. 20170520 DP阶段总结

    DP的力量不是无穷的. 但是,因为它叫做“动态规划”,它在OI界如鱼得水.这个“动态”不是指“离线”与“在线”,也不是什么“可持久化”.它只是把问题抽象为一个个“阶段”,在每一个“阶段”中作出或繁或简 ...

  3. tp5.1 insert 返回id, 不等于符号

    $insertId = Db::name('user_address')->insertGetId($data); //add=>insert, insert 返回值不再是插入的id; i ...

  4. snprintf()解析

    snprintf(ssid_mac,sizeof(ssid_mac),"%s_%02X%02X",ssid,macval[4],macval[5]); ssid_mac = ssi ...

  5. vsCode开发java遇到的问题整理、解决方案(持续更新)

    获取控制台输入的信息: 休息launch.json文件中的console属性internalConsole(内部控制台)修改为externalTerminal(外部控制台)即可正常获取输入信息,代码如 ...

  6. Java消息队列三道面试题详解!

    面试题 为什么使用消息队列? 消息队列有什么优点和缺点? Kafka.ActiveMQ.RabbitMQ.RocketMQ 都有什么区别,以及适合哪些场景? 面试官心理分析 其实面试官主要是想看看: ...

  7. 【精选】Ubuntu 14.04 安装Nginx、php5-fpm、ThinkPHP5.0(已经测试上线)

    sudo apt-get update 安裝Nginx https://www.vultr.com/docs/setup-nginx-rtmp-on-ubuntu-14-04 安裝完成後,Nginx的 ...

  8. charles抓包详解http 与 https

    包工具多种多样,比较好使的还是Charles和Fiddler,下面就简单的介绍下HTTPS的相关原理并以Charles为例来介绍下如何抓取HTTPS协议的包 1.下载charles 可以去charle ...

  9. Java并发编程原理与实战三十六:阻塞队列&消息队列

    一.阻塞队列 1.阻塞队列BlockingQueue ---->可以理解成生产者消费者的模式---->消费者要等待到生产者生产出来产品.---->而非阻塞队列ConcurrentLi ...

  10. SpringCloud微服务简介(一)

    Spring Cloud简单认识 微服务英文名称Microservice,Microservice架构模式就是将整个Web应用组织为一系列小的Web服务.这些小的Web服务可以独立地编译及部署,并通过 ...