目录
读写锁
与互斥量类似,但读写锁允许更高的并行性。其特性为:写独占,读共享。读写锁也叫共享-独占锁。当读写锁以读模式锁住时,它是以共享模式锁住的;当它以写模式锁住时,它是以独占模式锁住的。
读写锁非常适合于对数据结构读的次数远大于写的情况。
主要应用函数
pthread_rwlock_t rwlock;//定义一个读写锁变量
pthread_rwlock_init();
pthread_rwlock_destroy();
pthread_rwlock_rdlock();
pthread_rwlock_wrlock();
pthread_rwlock_tryrdlock();
pthread_rwlock_trywrlock();
pthread_rwlock_unock();
读写锁状态
读写锁只有一把,但其具备两种状态:
读模式下加锁状态(读锁)。
写模式下加锁状态(写锁)。
读写锁特性
读写锁是“写模式加锁”时, 解锁前,所有对该锁加锁的线程都会被阻塞。
读写锁是“读模式加锁”时, 如果线程以读模式对其加锁会成功;如果线程以写模式加锁会阻塞。
读写锁是“读模式加锁”时, 既有试图以写模式加锁的线程,也有试图以读模式加锁的线程。那么读写锁会阻塞随后的读模式锁请求。优先满足写模式锁。读锁、写锁并行阻塞,写锁优先级高。
pthread_rwlock_init
初始化一把读写锁。
man pthread_rwlock_init
参数rwlock
传出参数,调用时传&rwlock。
参数attr
互斥量属性,是一个传入参数,通常传NULL,选用默认属性(线程间共享)。
返回值
成功:0
失败:错误号
pthread_rwlock_destroy
销毁一把读写锁。
man pthread_rwlock_destroy
参数rwlock
传出参数,调用时传&rwlock。
返回值
成功:0
失败:错误号
pthread_rwlock_rdlock
以读方式请求读写锁。(常简称为:请求读锁)
man pthread_rwlock_rdlock
参数rwlock
传出参数,调用时传&rwlock。
返回值
成功:0
失败:错误号
pthread_rwlock_wrlock
以写方式请求读写锁。(常简称为:请求写锁)
man pthread_rwlock_wrlock
参数rwlock
传出参数,调用时传&rwlock。
返回值
成功:0
失败:错误号
pthread_rwlock_unlock
解锁。
man pthread_rwlock_unlock
参数rwlock
传出参数,调用时传&rwlock。
返回值
成功:0
失败:错误号
pthread_rwlock_tryrdlock
非阻塞以读方式请求读写锁。(非阻塞请求读锁)
man pthread_rwlock_tryrdlock
参数rwlock
传出参数,调用时传&rwlock。
返回值
成功:0
失败:错误号
pthread_rwlock_trywrlock
非阻塞以写方式请求读写锁。(非阻塞请求写锁)
man pthread_rwlock_trywrlock
参数rwlock
传出参数,调用时传&rwlock。
返回值
成功:0
失败:错误号
测试代码1
多个读线程和多个写线程同时争夺CPU。
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <pthread.h>
#include <string.h>
pthread_rwlock_t DuXie_Suo; //读写锁
int flag;
int temp = 0;
void *Du_XianCheng(void *arg) //读线程
{
int num = (int)arg;
while (1)
{
flag = pthread_rwlock_rdlock(&DuXie_Suo); //读方式加读写锁
if (flag != 0)
{
printf("读方式加读写锁错误:%s\n", strerror(flag));
exit(1);
}
printf("这是第%d个读线程,temp=%d,本线程ID是%lu。\n", num, temp, pthread_self());
flag = pthread_rwlock_unlock(&DuXie_Suo); //解读写锁
if (flag != 0)
{
printf("解读写锁错误:%s\n", strerror(flag));
exit(1);
}
sleep(2);
}
return NULL;
}
void *Xie_XianCheng(void *arg) //写线程
{
int num = (int)arg;
int old_temp; //旧的temp值
while (1)
{
flag = pthread_rwlock_wrlock(&DuXie_Suo); //写方式加读写锁
if (flag != 0)
{
printf("写方式加读写锁错误:%s\n", strerror(flag));
exit(1);
}
old_temp = temp;
usleep(1);
temp++;
printf("这是第%d个写线程,old_temp=%d,temp=%d,本线程ID是%lu。\n", num, old_temp, temp, pthread_self());
flag = pthread_rwlock_unlock(&DuXie_Suo); //解读写锁
if (flag != 0)
{
printf("解读写锁错误:%s\n", strerror(flag));
exit(1);
}
sleep(3);
}
return NULL;
}
int main(int argc, char *argv[])
{
pthread_t ZiXianCheng_ID[8]; //子线程ID
flag = pthread_rwlock_init(&DuXie_Suo, NULL); //初始化读写锁
if (flag != 0)
{
printf("初始化读写锁错误:%s\n", strerror(flag));
exit(1);
}
//创建8个子线程
for (int i = 0; i < 8; i++)
{
if (i < 3)
{
flag = pthread_create(&ZiXianCheng_ID[i], NULL, Xie_XianCheng, (void *)(i + 1)); //创建写子线程
}
else
{
flag = pthread_create(&ZiXianCheng_ID[i], NULL, Du_XianCheng, (void *)(i + 1)); //创建读子线程
}
if (flag != 0)
{
printf("创建第%d个子线程错误:%s\n", i + 1, strerror(flag));
exit(1);
}
}
printf("开始回收子线程!\n");
for (int i = 0; i < 8; i++)
{
flag = pthread_join(ZiXianCheng_ID[i], NULL);
if (flag != 0)
{
printf("回收第%d个子线程错误:%s\n", i + 1, strerror(flag));
exit(1);
}
}
printf("回收子线程完成!\n");
flag = pthread_rwlock_destroy(&DuXie_Suo); //销毁读写锁
if (flag != 0)
{
printf("销毁读写锁错误:%s\n", strerror(flag));
exit(1);
}
pthread_exit(NULL);
return 0;
}
测试结果
死锁
是使用不恰当导致的现象。
线程试图对同一个互斥量A加锁两次。
线程1拥有A锁,请求获得B锁;线程2拥有B锁,请求获得A锁。
条件变量
条件变量本身不是锁!但它也可以造成线程阻塞。通常与互斥锁配合使用。给多线程提供一个会合的场所。
主要应用函数
pthread_cond_t cond;//定义条件变量
pthread_cond_init();
pthread_cond_destroy();
pthread_cond_wait();
pthread_cond_timedwait();
pthread_cond_signal();
pthread_cond_broadcast();
pthread_cond_init
初始化一个条件变量。
man pthread_cond_init
参数cond
条件变量。
参数attr
条件变量属性,通常为默认值,传NULL即可。
返回值
成功:0
失败:错误号
动态初始化
pthread_cond_t cond;
pthread_cond_init(&cond,NULL); //动态初始化
静态初始化
pthread_cond_t cond=PTHREAD_COND_INITIALIZER; //静态初始化
pthread_cond_destroy
销毁一个条件变量。
man pthread_cond_destroy
参数cond
条件变量。
返回值
成功:0
失败:错误号
pthread_cond_wait
阻塞等待一个条件变量。
man pthread_cond_wait
参数cond
条件变量。
参数mutex
传出参数,调用时传&mutex,互斥锁。
返回值
成功:0
失败:错误号
作用
阻塞等待条件变量cond(参1)满足。
释放已掌握的互斥锁(解锁互斥量)相当于pthread_mutex_unlock(&mutex);
当被唤醒,pthread_cond_wait函数返回时,解除阻塞并重新申请获取互斥锁pthread_mutex_lock(&mutex);
1、2为一个原子操作。
pthread_cond_timedwait
限时等待一个条件变量。
man pthread_cond_timedwait
参数cond
条件变量。
参数mutex
传出参数,调用时传&mutex,互斥锁。
参数abstime
绝对时间。
struct timespec {
time_t tv_sec; /* seconds 秒*/
long tv_nsec; /* nanosecondes 纳秒*/
}
用法:
time_t cur = time(NULL); //获取当前时间。
struct timespec t; //定义 timespec 结构体变量 t
t.tv_sec = cur+1; //定时 1 秒
pthread_cond_timedwait (&cond, &mutex, &t); //传参
返回值
成功:0
失败:错误号
pthread_cond_signal
唤醒至少一个阻塞在条件变量上的线程。
man pthread_cond_signal
参数cond
条件变量。
返回值
成功:0
失败:错误号
pthread_cond_broadcast
唤醒全部阻塞在条件变量上的线程。
man pthread_cond_broadcast
参数cond
条件变量。
返回值
成功:0
失败:错误号
测试代码2
有两个线程,一个模拟生产者行为,一个模拟消费者行为。两个线程同时操作一个共享资源,生产者向其中添加产品,消费者从中消费掉产品。线程同步典型的案例即为生产者消费者模型,而借助条件变量来实现这一模型,是比较常见的一种方法。
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <pthread.h>
#include <string.h>
pthread_mutex_t HuChiSuo = PTHREAD_MUTEX_INITIALIZER; //互斥锁,静态初始化
pthread_cond_t TiaoJian_BianLiang = PTHREAD_COND_INITIALIZER; //条件变量,静态初始化
struct NengLiang //能量类型的结构体
{
struct NengLiang *next;
int num;
};
struct NengLiang *Bing; //饼
int flag;
void *ShengChanZhe(void *arg) //生产者
{
while (1)
{
struct NengLiang *ZuoBing = malloc(sizeof(struct NengLiang)); //做饼
ZuoBing->num = rand() % 1000 + 1;
flag = pthread_mutex_lock(&HuChiSuo); //加锁
if (flag != 0)
{
printf("加锁错误:%s\n", strerror(flag));
exit(1);
}
ZuoBing->next = Bing;
Bing = ZuoBing;
printf("这是生产者,做的饼是%d。\n", ZuoBing->num);
flag = pthread_mutex_unlock(&HuChiSuo); //解读写锁
if (flag != 0)
{
printf("解锁错误:%s\n", strerror(flag));
exit(1);
}
pthread_cond_signal(&TiaoJian_BianLiang); //唤醒阻塞线程,叫消费者吃饼
sleep(rand() % 3);
}
return NULL;
}
void *XiaoFeiZhi(void *arg) //消费者
{
while (1)
{
struct NengLiang *ChiBing; //吃饼
flag = pthread_mutex_lock(&HuChiSuo); //加锁
if (flag != 0)
{
printf("加锁错误:%s\n", strerror(flag));
exit(1);
}
if (Bing == NULL) //如果饼为空,说明没有饼
{
flag = pthread_cond_wait(&TiaoJian_BianLiang, &HuChiSuo); //阻塞等待饼的产生
if (flag != 0)
{
printf("阻塞等待错误:%s\n", strerror(flag));
exit(1);
}
}
ChiBing = Bing;
Bing = ChiBing->next;
printf("这是消费者,吃的饼是%d。\n", ChiBing->num);
flag = pthread_mutex_unlock(&HuChiSuo); //解锁
if (flag != 0)
{
printf("解读写锁错误:%s\n", strerror(flag));
exit(1);
}
free(ChiBing); //清空结构体内容
sleep(rand() % 3);
}
return NULL;
}
int main(int argc, char *argv[])
{
pthread_t ShengChanZhe_ID; //生产者线程ID
pthread_t XiaoFeiZhe_ID; //消费者线程ID
//创建线程
flag = pthread_create(&ShengChanZhe_ID, NULL, ShengChanZhe, NULL); //创建生产者子线程
if (flag != 0)
{
printf("创建生产者子线程错误:%s\n", strerror(flag));
exit(1);
}
flag = pthread_create(&XiaoFeiZhe_ID, NULL, XiaoFeiZhi, NULL); //创建消费者子线程
if (flag != 0)
{
printf("创建消费者子线程错误:%s\n", strerror(flag));
exit(1);
}
printf("开始回收子线程!\n");
flag = pthread_join(ShengChanZhe_ID, NULL);
if (flag != 0)
{
printf("回收生产者子线程错误:%s\n", strerror(flag));
exit(1);
}
flag = pthread_join(XiaoFeiZhe_ID, NULL);
if (flag != 0)
{
printf("回收消费者子线程错误:%s\n", strerror(flag));
exit(1);
}
printf("回收子线程完成!\n");
flag = pthread_mutex_unlock(&HuChiSuo); //销毁读写锁
if (flag != 0)
{
printf("销毁互斥锁错误:%s\n", strerror(flag));
exit(1);
}
pthread_exit(NULL);
return 0;
}
测试结果
测试代码3
多个消费者的情况下,争饼吃。
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <pthread.h>
#include <string.h>
pthread_mutex_t HuChiSuo = PTHREAD_MUTEX_INITIALIZER; //互斥锁,静态初始化
pthread_cond_t TiaoJian_BianLiang = PTHREAD_COND_INITIALIZER; //条件变量,静态初始化
struct NengLiang //能量类型的结构体
{
struct NengLiang *next;
int num;
};
struct NengLiang *Bing; //饼
int flag;
void *ShengChanZhe(void *arg) //生产者
{
while (1)
{
struct NengLiang *ZuoBing = malloc(sizeof(struct NengLiang)); //做饼
ZuoBing->num = rand() % 1000 + 1;
flag = pthread_mutex_lock(&HuChiSuo); //加锁
if (flag != 0)
{
printf("加锁错误:%s\n", strerror(flag));
exit(1);
}
ZuoBing->next = Bing;
Bing = ZuoBing;
printf("这是生产者,做的饼是%d。\n", ZuoBing->num);
flag = pthread_mutex_unlock(&HuChiSuo); //解读写锁
if (flag != 0)
{
printf("解锁错误:%s\n", strerror(flag));
exit(1);
}
pthread_cond_signal(&TiaoJian_BianLiang); //唤醒阻塞线程,叫消费者吃饼
sleep(rand() % 2);
}
return NULL;
}
void *XiaoFeiZhi(void *arg) //消费者
{
while (1)
{
struct NengLiang *ChiBing; //吃饼
flag = pthread_mutex_lock(&HuChiSuo); //加锁
if (flag != 0)
{
printf("加锁错误:%s\n", strerror(flag));
exit(1);
}
while (Bing == NULL) //如果饼为空,说明没有饼,多个消费者,需要多次判断
{
flag = pthread_cond_wait(&TiaoJian_BianLiang, &HuChiSuo); //阻塞等待饼的产生
if (flag != 0)
{
printf("阻塞等待错误:%s\n", strerror(flag));
exit(1);
}
}
ChiBing = Bing;
Bing = ChiBing->next;
printf("这是消费者,吃的饼是%d,线程ID是%lu。\n", ChiBing->num, pthread_self());
flag = pthread_mutex_unlock(&HuChiSuo); //解锁
if (flag != 0)
{
printf("解读写锁错误:%s\n", strerror(flag));
exit(1);
}
free(ChiBing); //清空结构体内容
sleep(rand() % 5);
}
return NULL;
}
int main(int argc, char *argv[])
{
pthread_t ShengChanZhe_ID; //生产者线程ID
pthread_t XiaoFeiZhe_ID; //消费者线程ID
//创建线程
flag = pthread_create(&ShengChanZhe_ID, NULL, ShengChanZhe, NULL); //创建生产者子线程
if (flag != 0)
{
printf("创建生产者子线程错误:%s\n", strerror(flag));
exit(1);
}
for (int i = 0; i < 3; i++)
{
flag = pthread_create(&XiaoFeiZhe_ID, NULL, XiaoFeiZhi, NULL); //创建消费者子线程
if (flag != 0)
{
printf("创建消费者子线程错误:%s\n", strerror(flag));
exit(1);
}
}
printf("开始回收子线程!\n");
flag = pthread_join(ShengChanZhe_ID, NULL);
if (flag != 0)
{
printf("回收生产者子线程错误:%s\n", strerror(flag));
exit(1);
}
flag = pthread_join(XiaoFeiZhe_ID, NULL);
if (flag != 0)
{
printf("回收消费者子线程错误:%s\n", strerror(flag));
exit(1);
}
printf("回收子线程完成!\n");
flag = pthread_mutex_unlock(&HuChiSuo); //销毁读写锁
if (flag != 0)
{
printf("销毁互斥锁错误:%s\n", strerror(flag));
exit(1);
}
pthread_exit(NULL);
return 0;
}
测试结果
信号量
应用于线程、进程间同步。
相当于初始化值为N的互斥量。N值:表示可以同时访问共享数据区的线程数。
主要应用函数
sem_t sem; //规定信号量 sem 不能 < 0。本质仍是结构体。但应用期间可简单看作为整数,忽略实现细节。
sem_init();
sem_destroy();
sem_wait();
sem_trywait();
sem_timedwait();
sem_post();
sem_init
初始化一个信号量。
man sem_init
参数sem
信号量。
参数pshared
0:用于线程间同步
1:用于进程间同步
参数value
同时访问的线程数。
返回值
成功:0
失败:错误号
sem_destroy
销毁一个信号量。
man sem_destroy
参数sem
信号量。
返回值
成功:0
失败:错误号
sem_wait
给信号量加锁。一次调用,做一次--操作,当信号量的值为0时,再次--就会阻塞。
man sem_wait
参数sem
信号量。一次调用,做一次++操作,当信号量的值为N时,再次++就会阻塞。
返回值
成功:0
失败:错误号
sem_post
N值,给信号量解锁。
man sem_post
参数sem
信号量。
返回值
成功:0
失败:错误号
sem_trywait
尝试对信号量加锁。
man sem_trywait
参数sem
信号量。
返回值
成功:0
失败:错误号
sem_timedwait
限时尝试对信号量加锁。
man sem_timedwait
参数sem
信号量。
参数abstime
绝对时间。
struct timespec {
time_t tv_sec; /* seconds 秒*/
long tv_nsec; /* nanosecondes 纳秒*/
}
用法:
time_t cur = time(NULL); //获取当前时间。
struct timespec t; //定义 timespec 结构体变量 t
t.tv_sec = cur+1; //定时 1 秒
sem_timedwait(&sem,&t); //传参
测试代码4
使用信号量完成线程间同步,模拟生产者,消费者问题。 如果□中有数据,生产者不能生产,只能阻塞。如果□中没有数据,消费者不能消费,只能等待数据。
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <semaphore.h>
#include <pthread.h>
#include <string.h>
#define NUM 5
int HuoJia[NUM]; //货架
sem_t KongHuoJia_XinHaoLiang; //空货架信号量
sem_t ChanPin_XinHaoLiang; //产品信号量
int flag;
void *ShengChanZhe(void *arg) //生产者
{
int i = 0;
while (1)
{
flag = sem_wait(&KongHuoJia_XinHaoLiang); //阻塞等待生产货物
if (flag != 0)
{
printf("阻塞等待生产货物错误:%s\n", strerror(flag));
exit(1);
}
HuoJia[i] = rand() % 1000 + 1;
printf("这是生产者,生产的货物是%d。\n", HuoJia[i]);
i++;
i = i % NUM;
flag = sem_post(&ChanPin_XinHaoLiang); //增加货物,产品
if (flag != 0)
{
printf("增加货物错误:%s\n", strerror(flag));
exit(1);
}
sleep(rand() % 2);
}
return NULL;
}
void *XiaoFeiZhi(void *arg) //消费者
{
int i = 0;
while (1)
{
flag = sem_wait(&ChanPin_XinHaoLiang); //阻塞等待消费货物,产品
if (flag != 0)
{
printf("阻塞等待消费货物:%s\n", strerror(flag));
exit(1);
}
printf("这是消费者,消费的产品是%d。\n", HuoJia[i]);
HuoJia[i] = 0;
i++;
i = i % NUM;
flag = sem_post(&KongHuoJia_XinHaoLiang); //增加空货架
if (flag != 0)
{
printf("增加空货架错误:%s\n", strerror(flag));
exit(1);
}
sleep(rand() % 3);
}
return NULL;
}
int main(int argc, char *argv[])
{
pthread_t ShengChanZhe_ID; //生产者线程ID
pthread_t XiaoFeiZhe_ID; //消费者线程ID
//初始化信号量
flag = sem_init(&KongHuoJia_XinHaoLiang, 0, NUM);
if (flag != 0)
{
printf("初始化空货架信号量错误:%s\n", strerror(flag));
exit(1);
}
flag = sem_init(&ChanPin_XinHaoLiang, 0, 0);
if (flag != 0)
{
printf("初始化产品信号量错误:%s\n", strerror(flag));
exit(1);
}
//创建线程
flag = pthread_create(&ShengChanZhe_ID, NULL, ShengChanZhe, NULL); //创建生产者子线程
if (flag != 0)
{
printf("创建生产者子线程错误:%s\n", strerror(flag));
exit(1);
}
flag = pthread_create(&XiaoFeiZhe_ID, NULL, XiaoFeiZhi, NULL); //创建消费者子线程
if (flag != 0)
{
printf("创建消费者子线程错误:%s\n", strerror(flag));
exit(1);
}
printf("开始回收子线程!\n");
flag = pthread_join(ShengChanZhe_ID, NULL);
if (flag != 0)
{
printf("回收生产者子线程错误:%s\n", strerror(flag));
exit(1);
}
flag = pthread_join(XiaoFeiZhe_ID, NULL);
if (flag != 0)
{
printf("回收消费者子线程错误:%s\n", strerror(flag));
exit(1);
}
printf("回收子线程完成!\n");
//销毁信号量
flag = sem_destroy(&KongHuoJia_XinHaoLiang); //销毁空货架信号量
if (flag != 0)
{
printf("销毁空货架信号量错误:%s\n", strerror(flag));
exit(1);
}
flag = sem_destroy(&ChanPin_XinHaoLiang); //销毁产品信号量
if (flag != 0)
{
printf("销毁产品信号量错误:%s\n", strerror(flag));
exit(1);
}
pthread_exit(NULL);
return 0;
}