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

it2022-05-09 37

互斥锁

[plain] view plain copy pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER; 或 pthread_mutex_t mutex; int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr) int pthread_mutex_lock(pthread_mutex_t *mutex) int pthread_mutex_unlock(pthread_mutex_t *mutex) int pthread_mutex_trylock(pthread_mutex_t *mutex)

信号量

[plain] view plain copy sem_t sem_event; int sem_init(sem_t *sem, int pshared, unsigned int value) int sem_destroy(sem_t * sem) int sem_post(sem_t * sem) int sem_wait(sem_t * sem) int sem_trywait(sem_t * sem) int sem_getvalue(sem_t * sem, int * sval)

条件变量

[plain] view plain copy pthread_cond_t cond=PTHREAD_COND_INITIALIZER; 或 pthread_cond_t cond； int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr) int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex) int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime) pthread_cond_signal()

互斥锁

读写锁

死锁

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

死锁的4个必要条件

互斥条件：资源是独占的且排他使用，进程互斥使用资源，即任意时刻一个资源只能给一个进程使用，其他进程若申请一个资源，而该资源被另一进程占有时，则申请者等待直到资源被占有者释放。不可剥夺条件：进程所获得的资源在未使用完毕之前，不被其他进程强行剥夺，而只能由获得该资源的进程资源释放。请求和保持条件：进程每次申请它所需要的一部分资源，在申请新的资源的同时，继续占用已分配到的资源。循环等待条件：在发生死锁时必然存在一个进程等待队列{P1,P2,…,Pn},其中P1等待P2占有的资源，P2等待P3占有的资源，…，Pn等待P1占有的资源，形成一个进程等待环路，环路中每一个进程所占有的资源同时被另一个申请，也就是前一个进程占有后一个进程所深情地资源。

条件变量：

相关函数：

初始化一个条件变量：函数原型：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) // 必须用while判断条件，因为在cond_signal 和 wait之间有个时间差，在这个差值时间内，可能有另一个消费者使head为空了 { 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; }

转载于:https://www.cnblogs.com/fchy822/p/9050821.html

相关资源：数据结构—成绩单生成器

专利

最新回复(0)

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

互斥锁

相关概念：

相关函数：

读写锁

相关概念：

相关函数：

死锁

条件变量：

相关概念：

相关函数：

专利

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