Posix信号量与互斥锁

1、 sem_wait()、sem_post()既可以用于有名的信号量的PV操作，也可以用于无名的信号量的PV操作。

sem_init()用于初始化无名信号量。

  在linux下man sem_init，查看函数的原型：int sem_init(sem_t *sem, int pshared, unsigned int value);

  无名信号量仍然可以应用于不同进程之间多线程之间的通信，取决于参数的设置。条件如下：1、第一个参数sem必须处于共享内存区，第二个参数非0。

        sem_destroy()用于销毁一个信号量。

2、  Posix互斥锁，该互斥锁也是无名的，也可以应用于不同进程之间多线程之间的通信，常用函数如下：

pthread_mutex_init 初始化一个互斥锁

        pthread_mutex_lock 锁定一个互斥锁

        pthread_mutex_unlock 解锁一个互斥锁

        pthread_mutex_destroy 销毁互斥锁

利用以上的知识可以实现生产者与消费者模型。

代码如下：

#define CONSUMERS_COUNT 1
#define PRODUCERS_COUNT 2
#define BUFFSIZE 10

int g_buffer[BUFFSIZE];

unsigned short in = 0;
unsigned short out = 0;
unsigned short prodece_id = 0;
unsigned short consume_id = 0;

sem_t g_sem_full;
sem_t g_sem_empty;

pthread_mutex_t g_mutex;

pthread_t g_thread[CONSUMERS_COUNT + PRODUCERS_COUNT];

void* consume(void *arg)
{
    int num = (int)arg;
    printf("%d wait buffer not emtpy\n", num);
    //消费者不停的消费产品
    while(1)
    {
        sem_wait(&g_sem_empty);
        pthread_mutex_lock(&g_mutex);

	for(i=0; i<BUFFSIZE; i++)
	{
	    printf("%02d ",i);
            printf("%d", g_buffer[i]);
	    if (g_buffer[i] == -1)
            {
	        printf("%s","null");
	    }
            else
            {
		printf("%d", g_buffer[i]);
            }

	    if (i == in)
            {
		printf("\t<--consume");
            }
	    
	    printf("\n");
	}
	consume_id = g_buffer[out];
	printf("%d begin consume product %d\n", num, consume_id);
        g_buffer[out] = -1;
        out = (out + 1)% BUFFSIZE;
        printf("%d end consume_id product %d\n", num, consume_id);

        pthread_mutex_unlock(&g_mutex);
        sem_post(&g_sem_full);
	sleep(1);
    }
    return NULL;
}
  
void* produce(void *arg)
{
    int i;
    int num = (int)arg;
    //生产者不停的生产
    while(1)
    {
	printf("%d wait buffer not full\n", num);
        sem_wait(&g_sem_full);
        pthread_mutex_lock(&g_mutex);
	
	for(i=0; i<BUFFSIZE; i++)
	{
	    printf("%02d ",i);
            printf("%d", g_buffer[i]);
	    if (g_buffer[i] == -1)
            {
	        printf("%s","null");
	    }
            else
            {
		printf("%d", g_buffer[i]);
            }

	    if (i == in)
            {
		printf("\t<--produce");
            }
	    
	    printf("\n");
	}
	printf("%d begin produce product %d\n", num, produce_id);
        g_buffer[in] = produce_id;
        in = (in+1)% BUFFSIZE;
        printf("%d end produce product %d\n", num, produce_id++);
	


        pthread_mutex_unlock(&g_mutex);
        sem_post(&g_sem_empty);
	sleep(1);
    }
    return NULL;
}

int main(void)
{
    int i;
    for(i=0; i<BUFFSIZE; i++)
        g_buffer[i] = -1;
    sem_init(&g_sem_full, 0, BUFFSIZE);
    sem_init(&g_sem_empty,0,0);
    pthread_mutex_init(&g_mutex,NULL);

    int i;
    for (i=0; i< CONSUMERS; i++)
    {
        pthread_create(&g_thread[i], NULL, consume, (void*)i);
    }
   
    for (i=0; i< PRODUCERS_COUNT; i++)
    {
        pthread_create(&g_thread[i+ CONSUMERS], NULL, produce, (void*)i);
    } 

    for (i=0; i< CONSUMERS + PRODUCERS_COUNT; i++)
    {
        pthread_join(&g_thread[i], NULL);
    }

    //销毁信号量
    sem_destroy(&g_sem_full);
    sem_destroy(&g_sem_empty);
    pthread_mutex_destroy(&g_mutex);

    return 0;
}