Unix网络编程源码解析_进程间通信IPC之生产-消费者问题

一、生产者-消费者问题（非涉及同步），主要介绍线程函数的作用；

全局变量定义

int nitems; /* read-only by producer and consumer */
struct {
  pthread_mutex_t mutex;
  int buff[MAXNITEMS];
  int nput;
  int nval;
}shared = {PTHREAD_MUTEX_INITIALIZER};

void *produce(void *);
void *consume(void *);

main函数如下

int main(int argc, char **argv){

        /* 最多可容纳MAXNTHREADS个线程（实际没用到100个），count[i]数组用来存放第i个线程所执行的次数 */
        int i, nthreads, count[MAXNTHREADS];

        /* tid_produce[i]用来存放第i个线程的的标识 */
        pthread_t tid_produce[MAXNTHREADS], tid_consume;
       
        /* items表示生产的总条目 threads表示将有多少个线程来生产 */
        if (argc != 3)
                err_quit("usage: prodcons2 <#items> <#threads>");

        nitems = min(atoi(argv[1]), MAXNITEMS);/* 命令行参数1（生产的总条目）与10000作比较，取最小值 */
        nthreads = min(atoi(argv[2]), MAXNTHREADS);/* 命令行参数2（线程数）与100作比较，取最小值 */
    
        /* Linux标准调用pthread_setconcurrency()函数 */
        Set_concurrency(nthreads);
/* ------------------------------------------------开始生产------------------------------------------------------------------ */
        /* 创建生产线程，&tid_produce[i]为线程标识地址，tid_produce[i]为线程标识的值，&count[i]为传入地址，count[i] 统计第i个线程所执行的次数（值） */
        for (i = 0; i < nthreads; i++) {
                count[i] = 0;
                Pthread_create(&tid_produce[i], NULL, produce, &count[i]);
        }

        /*pthread_join()作用是等tid_produce[i]的线程执行完，即阻塞运行，如果线程不执行完，我就不继续往下执行*/
        for (i = 0; i < nthreads; i++) {
                Pthread_join(tid_produce[i], NULL);
                printf("count[%d] = %d\n", i, count[i]);
        }
/* ------------------------------------------------生产完成-------------------------------------------------------------------- */
        /* 创建一个消费线程*/
        Pthread_create(&tid_consume, NULL, consume, NULL);
        Pthread_join(tid_consume, NULL);

        exit(0);
}

其中Set_concurrency()的函数，调用的函数原型是pthread_setconcurrency()，其作用是让系统知道并发运行的线程数量，这样每个生产的线程都会执行到；资料介绍如果在某些系统（Slaris）下省略该调用，会导致只有一个生产线程 执行；

生产者函数如下

static int num = 1;
/*只打印一次，查看shared.nput与shared.nval的初值，通过程序执行为0
void *produce(void *arg){
        for ( ; ; ) {
                 /* 加锁 */
                Pthread_mutex_lock(&shared.mutex);
                /* nitems 为要生产的总条目，为命令行参数1，演示输入的1000000*/
                if (shared.nput >= nitems) {
                        /* 解锁 */
                        Pthread_mutex_unlock(&shared.mutex);
                        return(NULL);
                }
                if(num > 0){
                        printf("shared.nput: %d--,shared.nval：
 %d--\n",shared.nput,shared.nval);
                        num--;
                }
                shared.buff[shared.nput] = shared.nval;//对应buff[i]存放的值为i
                shared.nput++;
                shared.nval++;
                /* 解锁 */
                Pthread_mutex_unlock(&shared.mutex);
                *((int *) arg) += 1; 传入参数count[i]的值累加，i表示第i个线程，分配的空间在main函数中
        }
}

消费者函数如下：

void *consume(void *arg){
        int i;
        /* 对生产线程所生产的 nitems 条目进行检查*/
        for (i = 0; i < nitems; i++) {
                if (shared.buff[i] != i)
                        printf("buff[%d] = %d\n", i, shared.buff[i]);
        }
        return(NULL);
}

程序演示结果

以上为先用多个线程生产（多个线程访问共享数据时加锁），后用一个线程进行消费，没有涉及到同步问题，后续的同步问题都时在该程序基础上进行，所以有必要了解基本的源代码；

二、与一相比，变化的有两处，main函数和消费者函数

源码分析，与上面的程序相比，函数pthread_setconcurrency()调用的参数增加了1个，即并行执行的线程为生产和消费线程总数，消费线程执行的顺序改变了，基本上与生产线程一并启动；

int main(int argc, char **argv){

        int             i, nthreads, count[MAXNTHREADS];
        pthread_t       tid_produce[MAXNTHREADS], tid_consume;

        if (argc != 3)
                err_quit("usage: prodcons3 <#items> <#threads>");
        nitems = min(atoi(argv[1]), MAXNITEMS);
        nthreads = min(atoi(argv[2]), MAXNTHREADS);

        Set_concurrency(nthreads + 1);
        for (i = 0; i < nthreads; i++) {
                count[i] = 0;
                Pthread_create(&tid_produce[i], NULL, produce, &count[i]);
        }
    /* 与上面的相比，消费线程启动提前（基本与生产线程一起执行）*/
        Pthread_create(&tid_consume, NULL, consume, NULL);

        for (i = 0; i < nthreads; i++) {
                Pthread_join(tid_produce[i], NULL);
                printf("count[%d] = %d\n", i, count[i]);
        }
        Pthread_join(tid_consume, NULL);

        exit(0);
}

生产者的线程执行函数保持不变，改变的是消费者线程；

消费者线程执行如下

void consume_wait(int i){
        /*等待第i个条目是否生产完成，如果生产完成了就return；如果生产没完成，就while（1）执行[加锁、解锁]动作 （等待生产完成），该方法俗称轮转（spinning）或者轮询（polling）*/
        for ( ; ; ) {
                Pthread_mutex_lock(&shared.mutex);
                if (i < shared.nput) {
                        Pthread_mutex_unlock(&shared.mutex);
                        return;                 
                }
                Pthread_mutex_unlock(&shared.mutex);
        }
}

void * consume(void *arg){
        int     i;

        for (i = 0; i < nitems; i++) {
                consume_wait(i);/*等待第i个条目是否生产完成*/
                if (shared.buff[i] != i)
                        printf("buff[%d] = %d\n", i, shared.buff[i]);
        }
        return(NULL);
}

资料介绍这种轮询消费的方式对cpu是一种浪费；

三、与二相比，变化的有三处，第一是全局变量的定义；第二是生产者的函数；第三是消费者函数；另外main函数与二完全相同，相同的地方就不介绍了；

全局变量的定义

int     nitems;
int     buff[MAXNITEMS];
struct {
  pthread_mutex_t       mutex;
  int                   nput;   /* next index to store */
  int                   nval;   /* next value to store */
} put = { PTHREAD_MUTEX_INITIALIZER };/* 同一、二一样 */

struct {
  pthread_mutex_t       mutex;
  pthread_cond_t        cond;
  int                   nready; /* number ready for consumer */
} nready = { PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_INITIALIZER };
/* 初始化锁mutex为PTHREAD_MUTEX_INITIALIZER，条件变量cond为PTHREAD_COND_INITIALIZER  */

生产者函数

void* produce(void *arg)
{
        for ( ; ; ) {
                Pthread_mutex_lock(&put.mutex);
                if (put.nput >= nitems) {
                        Pthread_mutex_unlock(&put.mutex);
                        return(NULL);           /* array is full, we're done */
                }
                buff[put.nput] = put.nval;
                put.nput++;
                put.nval++;
                Pthread_mutex_unlock(&put.mutex);

                Pthread_mutex_lock(&nready.mutex);
                if (nready.nready == 0)
                        Pthread_cond_signal(&nready.cond);
                nready.nready++;
                Pthread_mutex_unlock(&nready.mutex);

                *((int *) arg) += 1;
        }
}

生产者多了个pthread_cond_signal（）函数，作用是唤醒等待正在等待nready.nready 其值变为非零的线程（消费者），需要与关联的互斥锁（nready.mutex）与条件变量（nready.cond）相互协作；

消费者函数

void *
consume(void *arg)
{
        int             i;

        for (i = 0; i < nitems; i++) {
                Pthread_mutex_lock(&nready.mutex);
                while (nready.nready == 0){
                     
                        Pthread_cond_wait(&nready.cond, &nready.mutex);
                        
                }
                nready.nready--;
               
                Pthread_mutex_unlock(&nready.mutex);

                if (buff[i] != i)
                        printf("buff[%d] = %d\n", i, buff[i]);
        }
        return(NULL);
}

消费者多了个pthread_cond_wait（）函数，当nready.nready 为零，资料介绍其作用①给nready.mutex解锁；②把消费者消线程投入睡眠，直到另外线程就条件变量nready.cond调用的pthread_cond_signal（）函数来唤醒；

以下为演示结果，为了更加直观，我在程序添加了打印信息：

static int num = 50;

生产者线程增加三处打印

在消费者增加四处打印信息

测试结果如下

 

前面的图是5个线程生产100个条目，后面图是是5个线程生产100w条目（注意关闭消费线程的第一条打印），发现根本没有执行thread_cond_wait（）函数；如何让thread_cond_wait（）执行呢？

更改主函数中线程启动的顺序，如下

如果只更改顺序还不行（尝试过），最好来点睡眠，调用thread_cond_wait（）先让消费者线程睡眠。

测试结果如下：

打印-----4--时，消费者线程已经进入睡眠，可以看到两次结果还不一样，我们只要看前面一张，后面一张不用管（可能跟操作系统执行的算法有关。那么执行顺序到底是怎样呢？

重新修改下打印信息的顺序

void produce(void *arg)
{
        for ( ; ; ) {
                Pthread_mutex_lock(&put.mutex);
                if (put.nput >= nitems) {
                        Pthread_mutex_unlock(&put.mutex);
                        return(NULL);           /* array is full, we're done */
                }
                buff[put.nput] = put.nval;
                put.nput++;
                put.nval++;
                Pthread_mutex_unlock(&put.mutex);

                Pthread_mutex_lock(&nready.mutex);
                if (nready.nready == 0){
                        if(num > 0){
                                printf("-----1--\n");
                                num--;
                        }
                        Pthread_cond_signal(&nready.cond);
                        if(num > 0){
                                printf("-----2--\n");
                                num--;
                        }
                }
                nready.nready++;
                if(num > 0){
                        printf("-----3--\n");
                        num--;
                }
                Pthread_mutex_unlock(&nready.mutex);
                if(num > 0){
                        printf("-----4--\n");
                        num--;
                }

                *((int *) arg) += 1;
        }
}
void *consume(void *arg)
{
        int             i;

        for (i = 0; i < nitems; i++) {
                        //printf("buff[%d] = %d\n", i, buff[i]);
                Pthread_mutex_lock(&nready.mutex);
                while (nready.nready == 0){
                        if(num > 0){
                                printf("-----5--\n");
                                num--;
                        }
                        Pthread_cond_wait(&nready.cond, &nready.mutex);
                        if(num > 0){
                                printf("-----6--\n");
                                num--;
                        }
                }
                nready.nready--;
                if(num > 0){
                        printf("-----7--\n");
                        num--;
                }
                Pthread_mutex_unlock(&nready.mutex);
                if(num > 0){
                        printf("-----8--\n");
                        num--;
                }



                if (buff[i] != i)
                        printf("buff[%d] = %d\n", i, buff[i]);
        }
        return(NULL);
}

运行结果如下：

可以看到thread_cond_wait（）先释放消费者线程的锁并让该线程睡眠，在thread_cond_wait（）返回前，重新上锁，此时while（nready.nready == 0）为假，终止循环；