POSIX信号量与互斥锁

POSIX信号量相关函数

有名信号量：

sem_open
信号量的打开

sem_close
信号量的关闭

sem_unlink
信号量的删除

无名信号量

sem_init
信号量初始化   （可以用于不同进程间的通信，取决于第二个参数非零，同时信号量的对象要在共享内存中）

sem_destroy
信号量销毁

sem_wait
对信号量的PV操作：可以对有名和无名操作

sem_post

POSIX互斥锁相关操作：

pthread_mutex_init
初始化一个互斥锁

pthread_mutex_lock
锁定操作

pthread_mutex_unlock
解锁操作

pthread_mutex_destroy
销毁锁（无名锁，也可以用于不同进程间操作）操作

自旋锁：

自旋锁类似于互斥锁，他的性能比互斥锁更高

自旋锁与互斥锁很重要的一个区别在与：线程在申请自旋锁的时候，线程不会挂起，他处于忙等待的状态

pthread_spin_init

pthread_spin_destroy

pthread_spin_lock

pthread_spin_unlock

读写锁：

1. 只要没有线程持有给定的读写锁用于写，那么任意数目的线程就可以持有读写锁用于读

2.仅当没有线程持有某个给定的读写锁用于读或者写时，才能分配读写锁用于写

3.读写锁用于读称为共享锁，读写锁用于写称为排他锁

pthread_rwlock_init

pthread_rwlock_destroy

int pthread_rwlock_rdlock

int pthread_rwlock_wrlock

int pthread_rwlock_unlock

#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <pthread.h>
#include <semaphore.h>

#define ERR_EXIT(m) \
do \
{ \
perror(m); \
exit(EXIT_FAILURE); \
}while(0)

#define CONSUMERS_COUNT 1
#define PRODUCERS_COUNT 2
#define BUFFSIZE 10
int g_buffer[BUFFSIZE];
pthread_t g_thread[CONSUMERS_COUNT + PRODUCERS_COUNT];

sem_t g_sem_full;
sem_t g_sem_empty;

pthread_mutex_t g_mutex;

unsigned short in = 0;
unsigned short out = 0;
unsigned produce_id = 0;
unsigned consum_id = 0;

void* consume(void* arg)
{
int i;
int num = (int)arg;
sem_wait(&g_sem_empty);
while(1)
{
pthread_mutex_lock(&g_mutex);
for(i = 0;i<BUFFSIZE ;i++)
{

printf("%02d",i);
sleep(1);
if(g_buffer[i] == -1)
{

printf("%s","NULL");
}
else
{
printf("g_buffer[%d]=%d",i,g_buffer[i]);
}
if(i == out)
{
printf("%\t<---consume");
}
printf("\n");

}
consum_id = g_buffer[out];
printf("begin consume product %d\n",consum_id );
g_buffer[out] = -1;
out = (out+1)%BUFFSIZE;
printf("end consume product %d\n",consum_id );
pthread_mutex_unlock(&g_mutex);
sem_post(&g_sem_full);

}
return NULL;

}
void* produce(void* arg)
{
int num = (int)arg;
int i;
while(1)
{
printf("%d wait buffer full\n",num);
sem_wait(&g_sem_full);
pthread_mutex_lock(&g_mutex);
for(i = 0;i < BUFFSIZE;i++)
{
printf("%02d",i);
sleep(1);
if(g_buffer[i] == -1)
{

printf("%s","NULL");
}
else
{
printf("g_buffer[%d]=%d",i,g_buffer[i]);
}
if(i == in)
{
printf("%\t<---produce");
}
printf("\n");
}
printf("begin produce product %d\n",produce_id);
g_buffer[in] = 9;
in = (in+1)%BUFFSIZE;
printf("end produce product %d\n",produce_id);
pthread_mutex_unlock(&g_mutex);
sem_post(&g_sem_empty);
//sleep(5);
}
return NULL;

}

int main()
{

sem_init(&g_sem_full, 0, BUFFSIZE);
sem_init(&g_sem_empty,0,0);
int i;
memset(g_buffer,0,sizeof(g_buffer));
for(i = 0;i< CONSUMERS_COUNT;i++)
{
pthread_create(&(g_thread[i]), NULL, consume, (void*)i);
}
for(i = CONSUMERS_COUNT;i<CONSUMERS_COUNT + PRODUCERS_COUNT;i++)
{
pthread_create(&(g_thread[i]), NULL, produce, (void*)i);
}

for(i = 0;i < CONSUMERS_COUNT + 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 1;
}