【Linux系统编程】33.读写锁、死锁、条件变量、信号量

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;
}