《UNIX网络编程 卷2》读书笔记（三）

多个生产者，单个消费者，只考虑生产者之间的同步互斥

#include     " unpipc.h "

#define     MAXNITEMS         1000000
#define     MAXNTHREADS            100

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   * ),  * consume( void   * );

int
main( int  argc,  char   ** argv)
{
    int            i, nthreads, count[MAXNTHREADS];
    pthread_t    tid_produce[MAXNTHREADS], tid_consume;

    if (argc != 3)
        err_quit("usage: prodcons2 <#items> <#threads>");
    nitems = min(atoi(argv[1]), MAXNITEMS);//生产者存放的条目数
    nthreads = min(atoi(argv[2]), MAXNTHREADS);//待创建的生产者线程数

    Set_concurrency(nthreads);//通知线程系统我们希望并发多少线程
        /**//* 4start all the producer threads */
    for (i = 0; i < nthreads; i++) {
        count[i] = 0;//计数器初始化为0
        Pthread_create(&tid_produce[i], NULL, produce, &count[i]);//创建生产者线程
    }

        /**//* 4wait for all the producer threads */
    for (i = 0; i < nthreads; i++) {
        Pthread_join(tid_produce[i], NULL);//等待生产者线程结束
        printf("count[%d] = %d\n", i, count[i]);    
    }
    //这样做的目的是为了避免生产者和消费者之间的同步问题，这里只考虑生产者之间的同步
        /**//* 4start, then wait for the consumer thread */
    Pthread_create(&tid_consume, NULL, consume, NULL);//创建消费者线程
    Pthread_join(tid_consume, NULL);

    exit(0);
}
/**/ /* end main */

/**/ /* include producer */
void   *
produce( void   * arg)
{
    for ( ; ; ) {
        Pthread_mutex_lock(&shared.mutex);
        if (shared.nput >= nitems) {//生产完毕
            Pthread_mutex_unlock(&shared.mutex);
            return(NULL);        /**//* array is full, we're done */
        }
        shared.buff[shared.nput] = shared.nval;
        shared.nput++;
        shared.nval++;
        Pthread_mutex_unlock(&shared.mutex);
        *((int *) arg) += 1;//每个线程私有的计数器，不需要加锁
    }
}

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

    for (i = 0; i < nitems; i++) {
        if (shared.buff[i] != i)
            printf("buff[%d] = %d\n", i, shared.buff[i]);
    }
    return(NULL);
}
/**/ /* end producer */

生产者和消费者之间的同步，消费者采用的方式就是不断轮询。

#include     " unpipc.h "

#define     MAXNITEMS         1000000
#define     MAXNTHREADS            100

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   * ),  * consume( void   * );

/**/ /* include main */
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);

        /**//* 4create all producers and one consumer */
    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);

        /**//* 4wait for all producers and the consumer */
    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);
}
/**/ /* end main */

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

/**/ /* include consume */
void
consume_wait( int  i)
{
    for ( ; ; ) {
        Pthread_mutex_lock(&shared.mutex);
        if (i < shared.nput) {
            Pthread_mutex_unlock(&shared.mutex);
            return;            /**//* an item is ready */
        }
        Pthread_mutex_unlock(&shared.mutex);
    }
}

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

    for (i = 0; i < nitems; i++) {
        consume_wait(i);
        if (shared.buff[i] != i)
            printf("buff[%d] = %d\n", i, shared.buff[i]);
    }
    return(NULL);
}
/**/ /* end consume */

每个条件变量都有一个互斥锁与之关联，调用pthread_cond_wait等待某个条件为真时，同时指定其条件变量的地址和所关联的互斥锁的地址

   使用条件变量来通知，避免消费者轮询

/**/ /* include globals */
#include     " unpipc.h "

#define     MAXNITEMS         1000000
#define     MAXNTHREADS            100

         /**/ /* globals shared by threads */
int         nitems;                 /**/ /* read-only by producer and consumer */
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 } ;
/**/ /* end globals */

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

/**/ /* include main */
int
main( int  argc,  char   ** argv)
{
    int            i, nthreads, count[MAXNTHREADS];
    pthread_t    tid_produce[MAXNTHREADS], tid_consume;

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

    Set_concurrency(nthreads + 1);
        /**//* 4create all producers and one consumer */
    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);

        /**//* wait for all producers and the consumer */
    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);
}
/**/ /* end main */

/**/ /* include prodcons */
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++;//置为1 
        Pthread_mutex_unlock(&nready.mutex);

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

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);//wait条件变量
        nready.nready--;//置为0
        Pthread_mutex_unlock(&nready.mutex);

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