信号量互斥量读写锁条件变量

Posted 2020-11-06 fchy822

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了信号量互斥量读写锁条件变量相关的知识，希望对你有一定的参考价值。

互斥锁

读写锁

死锁

死锁不是一种锁，而是使用锁出现的一种现象。导致的结果就是程序一直阻塞。
造成死锁的主要原因有：
1.同一个线程对同一互斥量加锁两次
2.线程1拥有A锁，请求获得B锁；线程2拥有B锁，请求获得A锁
3.产生了震荡现象

条件变量：

相关函数：

初始化一个条件变量：
函数原型：int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);
返回值：成功返回0，失败返回错误码
参数：cond:条件变量；attr:条件变量属性，通常为默认值，传NULL即可

销毁一个条件变量：
函数原型：int pthread_cond_destroy(pthread_cond_t *restrict cond);
返回值：成功返回0，失败返回错误码
参数：cond:条件变量

阻塞等待一个条件变量：
函数原型：int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);
返回值：成功返回0，失败返回错误码
参数：cond:条件变量；mutex:传出参数，互斥锁
作用：
1.阻塞等待条件变量cond满足并解锁传入的互斥锁
2.被唤醒之后，该函数返回时，解除阻塞并重新给传入的互斥锁加锁

限时等待一个条件变量：
函数原型：int pthread_cond_timewait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex, const struct timespec *restirct abstime)
返回值：成功返回0，失败返回错误码
参数：cond:条件变量；mutex:传出参数，互斥锁；abstime：绝对时间。
第三个参数的用法：

time_t cur = time(null);    //获取当前时间
struct timespec t;  //定义结构体变量
t.tv_sec = cur + 1; //定时1s
pthread_cond_timewait(&cond, &mutex, &t);   //传参

唤醒至少一个阻塞在该条件变量上的线程：
函数原型：int pthread_cond_signal(pthread_cond_t *cond);
返回值：成功返回0，失败返回错误码
参数：cond:条件变量

唤醒全部阻塞在该条件变量上的线程：
函数原型：int pthread_cond_broadcast(pthread_cond_t *cond);
返回值：成功返回0，失败返回错误码
参数：cond:条件变量

下面是个比较经典的例子，即生产者消费者条件变量模型：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;      //全局变量的mutex可以通过这种方式初始化
pthread_cond_t  cond  = PTHREAD_COND_INITIALIZER;       //全局变量的cond可以通过这种方式初始化

struct node     //链表
{
    struct node *next;
    int counter;
};

struct node *head = NULL;

void *producter(void *arg)      //生产者
{
    struct node *p = NULL;
    while(1)
    {
        p = (struct node *)malloc(sizeof(struct node)); //生产者
        p->counter = rand() % 1000 + 1; //随即取一个值，作为生产的产品
        p->next = NULL;

        pthread_mutex_lock(&mutex); //上锁，如果不上锁，可能导致链表出现问题
        p->next = head;
        head = p;
        pthread_mutex_unlock(&mutex);   //解锁
        printf("producter:I has produced a product named %d\n", p->counter);
        pthread_cond_signal(&cond); //由于已经生产了一个产品，所以可以唤醒某个消费者了
        sleep(rand() % 5);      //为了便于观察，所以添加睡眠
    }
}

void *consumer(void *arg)   //消费者
{
    struct node *p = NULL;
    while(1)
    {
        pthread_mutex_lock(&mutex); //上锁
        while(head == NULL)  
        {
            pthread_cond_wait(&cond, &mutex);   //阻塞等待条件满足，并解锁mutex。满足条件之后，会自动重新给mutex加锁
        }
        p = head;
        head = p->next;     //模拟消费一个产品
        pthread_mutex_unlock(&mutex);       //解锁

        printf("consumer:I has taken a product named %d\n", p->counter);
        free(p);
        sleep(rand() % 5);

    }
}
int main()
{
    pthread_t tid[2];

    pthread_create(&tid[0], NULL, producter, NULL);
    pthread_create(&tid[1], NULL, consumer, NULL);

    pthread_join(tid[0], NULL);
    pthread_join(tid[1], NULL);

    return 0;

}

信号量：
相关概念：信号量相当于加强版的互斥锁。互斥锁在同一时刻只能有一个线程访问加锁的数据，但是信号量可以允许多个线程来访问。sem_t类型是一个结构体，但是使用时，可以简单的看成非负整数。

相关函数(头文件为：<semaphore.h>)：
初始化一个信号量：
函数原型：int sem_init(sem_t *sem, int pshared, unsigned int value)
返回值：成功返回0，失败返回-1并设置errno
参数：sem:代表信号量；pshared:取0代表用于线程间，取非0代表用于进程间；value:该参数指定信号量初值

销毁一个信号量：
函数原型：int sem_destroy(sem_t *sem)
返回值：成功返回0，失败返回-1并设置errno
参数：sem:代表信号量

给信号量加锁(相当于sem–)：
函数原型：int sem_wait(sem_t *sem)
返回值：成功返回0，失败返回-1并设置errno
参数：sem:代表信号量
当sem>0时，就可以正常执行，当sem = 0时会阻塞等待

给信号量解锁(相当于sem++)：
函数原型：int sem_post(sem_t *sem)
返回值：成功返回0，失败返回-1并设置errno
参数：sem:代表信号量

尝试给信号量加锁：
函数原型：int sem_trywait(sem_t *sem)
返回值：成功返回0，失败返回-1并设置errno
参数：sem:代表信号量

限时尝试给信号量加锁：
函数原型：int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout)
返回值：成功返回0，失败返回-1并设置errno
参数：sem:代表信号量;abs_timeout:代表定时的时间，用法和pthread_cond_timewait里面用法差不多

这里举一个生产者消费者信号量模型的例子：

#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <stdio.h>
#include <semaphore.h>

#define NUM 5               

int queue[NUM];                                     //全局数组实现环形队列
sem_t blank_number, product_number;                 //空格子信号量, 产品信号量

void *producer(void *arg)
{
    int i = 0;

    while (1) {
        sem_wait(&blank_number);                    //生产者将空格子数--,为0则阻塞等待
        queue[i] = rand() % 1000 + 1;               //生产一个产品
        printf("----Produce---%d\n", queue[i]);        
        sem_post(&product_number);                  //将产品数++

        i = (i+1) % NUM;                            //借助下标实现环形
        sleep(rand()%3);
    }
}

void *consumer(void *arg)
{
    int i = 0;

    while (1) {
        sem_wait(&product_number);                  //消费者将产品数--,为0则阻塞等待
        printf("-Consume---%d\n", queue[i]);
        queue[i] = 0;                               //消费一个产品 
        sem_post(&blank_number);                    //消费掉以后,将空格子数++

        i = (i+1) % NUM;
        sleep(rand()%3);
    }
}

int main(int argc, char *argv[])
{
    pthread_t pid, cid;

    sem_init(&blank_number, 0, NUM);                //初始化空格子信号量为5
    sem_init(&product_number, 0, 0);                //产品数为0

    pthread_create(&pid, NULL, producer, NULL);
    pthread_create(&cid, NULL, consumer, NULL);

    pthread_join(pid, NULL);
    pthread_join(cid, NULL);

    sem_destroy(&blank_number);
    sem_destroy(&product_number);

    return 0;
}

以上是关于信号量互斥量读写锁条件变量的主要内容，如果未能解决你的问题，请参考以下文章

LinuxC线程pthread线程同步进程同步-互斥量信号量条件变量读写锁文件锁

Linux多线程中互斥锁读写锁自旋锁条件变量信号量详解