生产者与消费者

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/types.h>
#include <time.h>
#include <fcntl.h>
#include <semaphore.h>
#include <sys/ipc.h>
#include <errno.h>
#define MYFIFO "myfifo"
#define BUFFER_SIZE 3
#define UNIT_SIZE 5
#define RUN_TIME 30
#define DELAY_TIME_LEVELS 5.0

void *producer(void *arg);
void *customer(void *arg);

int fd;
time_t end_time;
sem_t mutex,full,avail;

int main()
{
    int ret;
    pthread_t thrd_prd_id,thrd_cst_id;

    srand(time(NULL));
    end_time = time(NULL) + RUN_TIME;

        /*创建有名管道*/
    if((mkfifo(MYFIFO,0644) < 0) && (errno != EEXIST))
    {
        perror("mkfifo error!");
        exit(-1);
    }

        /*打开管道*/
    fd = open(MYFIFO,O_RDWR);
    if(fd == -1)
    {
        perror("open fifo error");
        exit(-1);
    }

        /*初始化互斥信号量为1*/
    ret = sem_init(&mutex,0,1);
        /*初始化avail信号量为 N */
    ret += sem_init(&avail,0,BUFFER_SIZE);
    /*初始化full信号量为0*/
    ret += sem_init(&full,0,0);

    if(ret != 0)
    {
        perror("sem_init error");
        exit(-1);
    }

        /*创建两个线程*/
    ret = pthread_create(&thrd_prd_id,NULL,producer,NULL);
    if(ret != 0)
    {
        perror("producer pthread_create error");
        exit(-1);
    }

    ret = pthread_create(&thrd_cst_id,NULL,customer,NULL);
    if(ret != 0)
    {
        perror("customer pthread_create error");
        exit(-1);
    }

    pthread_join(thrd_prd_id,NULL);
    pthread_join(thrd_cst_id,NULL);
    close(fd);
    unlink(MYFIFO);

    return 0;
}

void *producer(void *arg) //生产者线程
{
    int real_write;
    int delay_time;

    while(time(NULL) < end_time)
    {
        delay_time = (int)(rand() * DELAY_TIME_LEVELS/RAND_MAX/2.0) + 1;
        sleep(delay_time);

                /*P操作信号量avail和mutex*/
        sem_wait(&avail);
        sem_wait(&mutex);
        printf("\nproducer have delayed %d seconds\n",delay_time);

                /*生产者写入数据*/
        if((real_write = write(fd,"hello",UNIT_SIZE)) == -1)
        {
            if(errno == EAGAIN)
            {
                printf("The buffer is full,please wait for reading!\n");
            }
        }
        else
        {
            printf("producer writes %d bytes to the FIFO\n",real_write);        
            printf("Now,the buffer left %d spaces!\n",avail);
        }
                /*V操作信号量full 和 mutex*/
        sem_post(&full);
        sem_post(&mutex);
    }
    pthread_exit(NULL);
}

void *customer(void *arg) //消费者线程
{
    unsigned char read_buffer[UNIT_SIZE];
    int real_read;
    int delay_time;

    while(time(NULL) < end_time)
    {
        delay_time = (int)(rand() * DELAY_TIME_LEVELS/RAND_MAX/2.0) + 1;
        sleep(delay_time);

        sem_wait(&full); //P操作信号量full和mutex
        sem_wait(&mutex);
        memset(read_buffer,0,UNIT_SIZE);
        printf("\nCustomer have delayed %d seconds\n",delay_time);

        if((real_read = read(fd,read_buffer,UNIT_SIZE)) == -1)
        {
            if(errno == EAGAIN)
            {
                printf("The buffer is empty,please wait for writing!\n");
            }
        }
        else
        {
            printf("customer reads %d bytes from the FIFO\n",real_read);        
        }

        sem_post(&avail); //V操作信号量 avail 和 mutex
        sem_post(&mutex);       
    }

    pthread_exit(NULL);
}