1. 互斥量mutex
2. 读写锁:pthread_rwlock_t rwlock//非常适合读次数大于写次数的程序
读写锁的三种状态:读模式加锁、写模式加锁、不加锁。一次只有一个线程占用写模式的读写锁,但是多个线程可以同时占用读模式的读写锁。
读写锁在写加锁状态时,在被解锁前,所有试图这个锁加锁的线程将会阻塞。以读加锁时,所有试图读模式加锁的线程都能获得访问权限,但是如果希望以写模式加锁,则必须阻塞直到所有线程释放锁。
读写锁一读模式加锁时,如果有其他线程试图以写模式加锁,那么读写锁会阻塞随后的读模式加锁请求,避免锁长期占用。
pthread_rwlock_init初始化锁
pthread_rwlock_destroy销毁锁
pthread_rwlock_rdlock //读模式加锁
pthread_rwlock_tryrdlock
pthread_rwlock_wrlock //写模式加锁
pthread_rwlock_trywrlock
pthread_rwlock_unlock //解锁
3. 条件变量
当互斥量被锁住以后发现当前线程还是无法完成自己的操作,那么它应该释放互斥量,让其他线程工作:
a. 轮询的方法,不停的查询你需要的条件;
b. 系统帮你查询条件,使用条件变量pthread_condi_t cond
pthread_cond_init //初始化
pthread_cond_destroy //销毁
pthread_cond_wait //等待条件为真
参数中的互斥量对条件进行保护,传递锁住的互斥量
函数将线程放到等待条件的线程列表上,然后对互斥量进行解锁。当条件满足时函数返回,返回以后继续对互斥量加锁。
pthread_cond_timedwait //指定时间条件不满足,那么函数返回
条件满足时需要唤醒等待条件的线程
pthread_cond_boradcast //唤醒等待条件的所有线程
pthread_cond_signal //至少唤醒等待条件的一个线程
一定要在条件改变以后再唤醒进程
4. 一个很好的例子:说明了条件变量的使用
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <pthread.h>
#define BUFFER_SIZE 5 //产品库存大小
#define PRODUCT_CNT 50 //产品生产总数
struct product_cons
{
int buffer[BUFFER_SIZE]; //生产产品值
pthread_mutex_t lock; //互斥锁 volatile int
int readpos, writepos; //读写位置
pthread_cond_t notempty; //条件变量,非空
pthread_cond_t notfull; //非满
}buffer;
void init(struct product_cons *p)
{
pthread_mutex_init(&p->lock, NULL); //互斥锁
pthread_cond_init(&p->notempty, NULL); //条件变量
pthread_cond_init(&p->notfull, NULL); //条件变量
p->readpos = 0; //读写位置
p->writepos = 0;
}
void fini(struct product_cons *p)
{
pthread_mutex_destroy(&p->lock); //互斥锁
pthread_cond_destroy(&p->notempty); //条件变量
pthread_cond_destroy(&p->notfull); //条件变量
p->readpos = 0; //读写位置
p->writepos = 0;
}
void cleanup_handler(void *arg)
{
printf("cleanup_handler exec!\n");
pthread_mutex_t *lock = (pthread_mutex_t*)arg;
pthread_mutex_unlock(lock); //解锁
}
//存储 一个数据 到 bufferr
void put(struct product_cons *p, int data) //输入产品子函数
{
pthread_mutex_lock(&p->lock); //上锁
/*等待,直到 buffer 不为 满*/
while((p->writepos + 1) % BUFFER_SIZE == p->readpos) //测试空间是否已满
{
printf("producer wait for not full\n");
pthread_cond_wait(&p->notfull, &p->lock); //阻塞等待
//这里,生产者 notfull 等待消费者 pthread_cond_signal(&p->notfull);信号
//如果,消费者发送了 signal 信号,表示有了 空闲
}
p->buffer[p->writepos] = data; //写数据
p->writepos++;
if(p->writepos >= BUFFER_SIZE) //如果写到 尾部,返回
p->writepos = 0;
pthread_cond_signal(&p->notempty); //发送有数据信号
pthread_mutex_unlock(&p->lock); //解锁
}
//读,移除 一个数据 从 buffer
int get(struct product_cons *p)
{
int data = 0;
pthread_mutex_lock(&p->lock);
/*等待,直到不为空*/
while(p->writepos == p->readpos)
{
printf("consumer wait for not empty\n");
pthread_cond_wait(&p->notempty,&p->lock);
}
/*读 一个 数据*/
data = p->buffer[p->readpos];
p->readpos++;
if(p->readpos >= BUFFER_SIZE) //如果读到 尾
p->readpos = 0;
pthread_cond_signal(&p->notfull);
pthread_mutex_unlock(&p->lock);
return data;
}
void *producer(void *data) //子线程 ,生产
{
int n;
for(n = 1; n <= 50; ++n) //生产 50 个产品
{
sleep(1);
printf("put the %d product\n",n);
put(&buffer,n);
}
printf("producer stopped\n");
return NULL;
}
void *consumer(void *data)
{
static int cnt = 0;
while(1)
{
sleep(2);
printf("get the %d product\n", get(&buffer));
if(++cnt == PRODUCT_CNT)
break;
}
printf("consumer stopped\n");
return NULL;
}
int main(int argc, char *argv[])
{
pthread_t th_a,th_b;
void *retval;
init(&buffer);
pthread_create(&th_a, NULL, producer, 0);
pthread_create(&th_b, NULL, consumer, 0);
pthread_join(th_a, &retval);
pthread_join(th_b, &retval);
fini(&buffer);
return 0;
}
执行结果: