线程（三）：线程通信：同步(条件变量、无名信号量)+互斥（互斥锁）

已于 2024-03-22 17:26:16 修改
阅读量115 收藏
点赞数
分类专栏： Linux应用 文章标签： linux 线程间通信 线程 linux应用 同步 互斥
于 2023-11-07 10:38:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52864526/article/details/134253557
版权

文章目录

一、线程通信：互斥—>互斥锁

头文件：
#include <pthread.h>

1、定义线程互斥锁变量

pthreda_mutex_t mutex;

2、初始化互斥锁变量

2.1、静态初始化（默认模式）== 动态初始化时参数填 NULL

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

2.2、动态初始化

函数原型：
   int pthread_mutex_init(pthread_mutex_t *restrict mutex,
                const pthread_mutexattr_t *restrict attr);
参数：
    @mutex: 进行初始化的锁
    @attr : 线程属性，一般写为NULL
返回值：成功返回0   失败返回错误码

3. 上锁

函数原型：
    int pthread_mutex_lock(pthread_mutex_t *mutex);
    int pthread_mutex_trylock(pthread_mutex_t *mutex);
功能：上锁（尝试上锁）（如果之前锁没有被使用过，直接获取锁成功）                            
参数：    
    @mutex: 互斥锁的变量地址
返回值：成功返回0 失败错误码

4. 解锁-----不管是上锁还是尝试上锁，都用该函数解锁

函数原型：
    int pthread_mutex_unlock(pthread_mutex_t *mutex);
功能：解锁
参数：    
    @mutex: 互斥锁变量的首地址
返回值：成功0  失败错误码

5. 销毁锁

函数原型：
    int pthread_mutex_destroy(pthread_mutex_t *mutex);
功能：销毁锁
参数：    
    @mutex: 互斥锁变量的首地址
返回值：成功0  失败错误码

二、线程通信：同步—>无名信号量

头文件

#include <semaphore.h>

1、定义无名信号量

sem_t sem;

2、初始化无名信号量

函数原型：
    int sem_init(sem_t *sem, int pshared, unsigned int value);   
参数：
    @sem: 无名信号量变量的首地址
    @pshared: 是在线程还是进程间使用
        0: 两个线程的同步 （一般0）
        1: （非0）两个进程的同步（前提，两个进程是亲缘进程）  
    @value: 无名信号量的初始值
        如果value为0：表示线程获取不到信号量，将阻塞
                     （为0 就是阻塞等，什么时候数值+1， 什么时候可以申请信号量）
        如果value非0: 表示线程可以获取无名信号量
                      （一般为1 如果填1表示一个线程可以获取资源）
返回值：成功返回0  失败-1

3、获取信号量

     int sem_wait(sem_t *sem);
功能：相当于P操作，获取信号量（如果获取不到就阻塞）
参数：
    @sem : 无名信号量的首地址
返回值：成功返回0  失败-1

4、释放信号量

    int sem_post(sem_t *sem);
功能：相当于v操作+1，释放信号量
参数：
    @sem : 无名信号量的首地址
返回值：成功返回0  失败-1

5、销毁信号量

    int sem_destroy(sem_t *sem);
功能：销毁无名信号量
参数：
    @sem : 无名信号量的首地址
返回值：成功返回0  失败-1
只有已经被 sem_init 初始化的信号量才应该使用sem_destroy()销毁。
销毁当前被其他进程或线程阻塞的信号量(未释放的信号量)会产生未定义的行为。
使用已被销毁的信号量会产生未定义的结果，直到使用 sem_init 重新初始化该信号量。

示例：无名信号量的使用（重在理解，与参考）

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

//2. 定义无名信号量
sem_t sem1;
sem_t sem2;

//生产者线程
void *thread_handle1(void * arg){
    while(1){
        //获取无名信号量
        sem_wait(&sem1);            //sem1初始值为1，可以获取
        printf("生产一个面包\n");
        //4. 释放无名信号量
        sem_post(&sem2);
    }
}
//消费者线程
void *thread_handle2(void * arg){
    while(1){
        //获取无名信号量
        sem_wait(&sem2);            //sem2初始值为0，获取不到，阻塞
        printf("购买一个面包\n");

        
        //4. 释放无名信号量
        sem_post(&sem1);
    }
}
int main(){
    //1. 创建线程
    pthread_t tid1, tid2;
    
    if((errno = pthread_create(&tid1, NULL, thread_handle1, NULL)) != 0){
        perror("create tid1 :");return -1;
    }
    if((errno = pthread_create(&tid2, NULL, thread_handle2, NULL)) != 0){
        perror("create tid2 :");return -1;
    }
    //3. 初始化无名信号量
    sem_init(&sem1, 0, 1);
    sem_init(&sem2, 0, 0);
    
    //阻塞等待子线程结束为其回收资源
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    
    //5. 销毁无名信号量
    sem_destroy(&sem1);
    sem_destroy(&sem2);
    return 0;    
}

三、线程通信：同步—>条件变量

1、定义一个条件变量

pthread_cond_t cond;

2、初始化条件变量

2.1、静态初始化

 pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

2.2、动态初始化

   int pthread_cond_init(pthread_cond_t *restrict cond,
           const pthread_condattr_t *restrict attr);
    功能：初始化条件变量
    参数：
        @cond:条件变量首地址
        @attr:属性， NULL
    返回值：成功返回0   失败错误码

3、释放条件变量（由一个线程创造释放一个或多个条件变量）（先释放再获取）

 int pthread_cond_broadcast(pthread_cond_t *cond);
    功能：释放多个资源（释放所有资源）
    	（释放后，等待队列所有线程全部进行获取，形成队内无序，队间有序）
    参数：
         @cond: 条件变量的首地址
    返回值：成功返回0   失败错误码     
-----------------------------------------------------------------------------------------------------------------
    int pthread_cond_signal(pthread_cond_t *cond);
    功能：释放一个资源
    参数：
         @cond: 条件变量的首地址
    返回值：成功返回0 失败错误码

4、获取条件变量（可多个线程获取）（使用前定义并初始化一个互斥锁）

   int pthread_cond_wait(pthread_cond_t *restrict cond,
       pthread_mutex_t *restrict mutex);
 参数：
     @cond: 条件变量的首地址
     @mutex: 互斥锁 
     		(在调用pthread_cond_wait函数之前要定义并初始化一个互斥锁) 
         //1. 获取互斥锁
         //2. 调用pthread_cond_wait   
             //2.1 将当前的线程放入队列里
             //2.2 解锁
             //2.3 在队列里休眠
             //2.4 重新获取锁
             //从队列删除  
         //3. 执行代码   
         //4. 解锁
返回值：成功返回0   失败错误码

5、销毁条件变量

int pthread_cond_destroy(pthread_cond_t *cond);
功能：销毁条件变量
参数：
     @cond: 条件变量的首地址
返回值：成功返回0   失败错误码

示例：条件变量使用（一个消费者线程）（重在理解，与参考）

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

//定义条件变量
pthread_cond_t cond;
pthread_mutex_t mutex;


//生产者线程
void *thread_handle1(void * arg){
    //设为分离态
    //pthread_detach(pthread_self());
    while(1){
        sleep(1);
        printf("生产一个面包\n");
        pthread_cond_signal(&cond);    
    }
}

//消费者线程
void *thread_handle2(void * arg){
    while(1){
    pthread_cond_wait(&cond, &mutex);
        printf("购买一个面包\n");        
    }
}

int main(){
    //创建线程
    pthread_t tid1, tid2;    
    if((errno = pthread_create(&tid1, NULL, thread_handle1, NULL)) != 0){
        perror("create tid1 ");return -1;
    }
    if((errno = pthread_create(&tid2, NULL, thread_handle2, NULL)) != 0){
        perror("create tid2 ");return -1;
    }
    //初始化条件变量
    pthread_cond_init(&cond, NULL);
    
    //阻塞等待回收子线程资源
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    
    //销毁条件变量
    pthread_cond_destroy(&cond);
    
    return 0;
}

示例二： 条件变量使用（多个消费者线程）

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

//定义条件变量
pthread_cond_t cond;
pthread_mutex_t mutex;

//生产者线程
void *thread_handle(void * arg){
    //设为分离态
    //pthread_detach(pthread_self());
    while(1){
        sleep(1);
        //每次生产一个面包，释放一个资源
        //printf("生产一个面包\n");
        //pthread_cond_signal(&cond);    
        
        //每次生产多个，同时释放多个资源
        printf("生产5个面包\n");
        pthread_cond_broadcast(&cond);
    }
}

//消费者线程
void *thread_handle1(void * arg){
    //循环操作
    while(1){
        //1. 上锁(获取互斥锁)
        pthread_mutex_lock(&mutex);
        
        //2. 获取条件变量
        pthread_cond_wait(&cond, &mutex);
        
        //3. 执行代码
        printf("%ld 购买一个面包\n", pthread_self());        
        
        //4. 解锁
        pthread_mutex_unlock(&mutex);
    }
}

int main(){
    //创建线程
    pthread_t tid, tid1, tid2, tid3, tid4;
    
    if((errno = pthread_create(&tid, NULL,  thread_handle, NULL)) != 0){
        perror("create tid1 ");return -1;
    }
    if((errno = pthread_create(&tid1, NULL, thread_handle1, NULL)) != 0){
        perror("create tid2 ");return -1;
    }
    if((errno = pthread_create(&tid2, NULL, thread_handle1, NULL)) != 0){
        perror("create tid2 ");return -1;
    }
    if((errno = pthread_create(&tid3, NULL, thread_handle1, NULL)) != 0){
        perror("create tid2 ");return -1;
    }
    if((errno = pthread_create(&tid4, NULL, thread_handle1, NULL)) != 0){
        perror("create tid2 ");return -1;
    }

    //初始化条件变量和互斥锁变量
    pthread_cond_init(&cond, NULL);
    pthread_mutex_init(&mutex, NULL);
    
    //打印消费者线程号
    printf("tid1 = %ld\n", tid1);
    printf("tid2 = %ld\n", tid2);
    printf("tid3 = %ld\n", tid3);
    printf("tid4 = %ld\n", tid4);
    
    //阻塞等待回收子线程资源
    pthread_join(tid, NULL);
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    pthread_join(tid3, NULL);
    pthread_join(tid4, NULL);
    
    //销毁条件变量
    pthread_cond_destroy(&cond);
    pthread_mutex_destroy(&mutex);

    return 0;
}
好好睡觉好好吃饭
关注
专栏目录
线程同步=互斥锁+条件变量+信号量+文件锁(文件记录锁和文件锁) 死锁
qq_42024067的博客
10-16 815
（6）线程同步：目前实现线程同步的主要方式就是：互斥量、条件变量、信号量 线程的最大特点是资源的共享性，但资源共享中的同步问题是多线程编程的难点。 linux下提供了多种方式来处理线程同步，最常用的是互斥锁、条件变量和信号量。 互斥量（互斥锁） 　　在Linux操作系统中，用户层面上编程使用的所有锁都是建议锁，不具有强制性，因此访问共享数据的所有线程（进程）都应该先加锁才能访问。 　　互斥量提供...
Linux系统编程9(线程同步，互斥锁，读写锁，条件变量和信号量)
Haffuman_Tree的博客
09-27 523
本主要介绍线程同步的问题，包括互斥锁，条件变量和pv信号操作
无名信号量示例代码
06-15
Linux系统编程——线程同步与互斥：无名信号量，相关教程链接如下： http://blog.csdn.net/tennysonsky/article/details/46496201
使用线程间通信之条件变量
aodiyi6351的博客
07-01 143
近期用C++写安卓下的一个通讯程序。作为jni库给java调用，採用多线程轮询遇到一个问题描写叙述例如以下： A线程收到数据，放入队列，是生产者。 B、C、D若干个线轮询训消息队列，假设队列有数据就取出进行处理，没数据就Sleep(T)歇息，问题是这个T值取多大合适？取大了消息处理不及时。取小了手机cpu上升电池非常快耗光。 这个问题最佳解法是採用条件变量，能够比較完美...
【线程系列之三】条件变量介绍
最新发布
qq_40604302的博客
07-09 811
（Condition Variables）是并发编程中用于线程同步的一种机制，它通常与互斥锁（Mutex）一起使用，以允许线程以某种条件为基础来挂起（阻塞）和唤醒（继续执行）。在上述的生产-消费者模型中存在一个问题，及buffer最终会变为0，生产者线程在生产了10个产品后就结束了，而消费者线程则在一个无限循环中运行，不断尝试消费产品。在等待期间，会释放与条件变量关联的互斥锁，当线程被唤醒后重新获取互斥锁。（虽然在这个特定情况下可能不是必需的，因为消费者可能已经在等待）来唤醒可能还在等待的消费者线程。
Linux线程间通信-条件变量
qq_31193221的博客
01-01 546
Linux多线程通信学习之条件变量一、条件变量的介绍二、条件变量的创建和使用三、代码实例 从本篇开始对多线程通信的知识点进行整理，本篇主要介绍条件变量，有什么错误和建议请留言指教。有关前文多线程基础的整理请点此处。 一、条件变量的介绍 条件变量本质也是一个全局变量，它的功能是阻塞线程，直至接收到“条件成立”的信号后，被阻塞的线程才能继续执行。 #include <pthreadtypes.h> typedef union { struct __pthread_cond_s __data;
linux线程间通信-条件变量
背着行囊去远方的博客
09-03 679
条件变量（condition）：可以以原子的方式阻塞进程，直到某个特定条件为真为止。对条件的测试是在互斥锁的保护下进行的。条件变量始终与互斥锁一起使用。 互斥量是防止多线程同时访问共享的互斥变量来保护临界区。 条件变量是多线程间可以通过它来告知其他线程某个状态发生了改变，让等待在这个条件变量的线程继续执行。 设置一个条件变量让线程1等待在一个临界区的前面，当其他线程给这个变量执行通知操...
【C++多线程系列】【八】线程间通信之条件变量
weixin_33913332的博客
05-02 441
2019独角兽企业重金招聘Python工程师标准>>> ...
Linux下多线程编程的互斥与同步
07-31
在Linux中，实现了POSIX无名信号量，这些信号量可以在线程间共享。以下是一些重要的函数： 1. `sem_init`：用于创建信号量，并设定其初始值。第二个参数`pshared`在当前的Linux实现中必须为0，意味着信号量仅限于...
线程间通信的定义及全局变量的方法
07-21
为了解决线程间通信时出现的资源竞争问题，操作系统提供了几种同步机制，包括信号量（Semaphores）、互斥锁（Mutexes）和条件变量（Condition Variables）。它们允许我们在进行可能引起竞争的资源访问之前，先进行...
ch6-1 Windows进程通信 线程互斥和同步1
08-03
5. 条件变量（Condition Variables）：配合锁使用，让线程等待特定条件满足后继续执行。 6. 等待链表（Wait Functions）：如WaitForMultipleObjects，使线程等待一个或多个对象的状态改变。 信号处理在Windows中...
Linux系统编程（无名信号量）
小麦大大博客
01-12 879
信号量概述 信号量广泛用于进程或线程间的同步和互斥，信号量本质上是一个非负的整数计数器，它被用来控制对公共资源的访问。 编程时可根据操作信号量值的结果判断是否对公共资源具有访问的权限，当信号量值大于 0 时，则可以访问，否则将阻塞。PV原语是对信号量的操作，一次 P 操作使信号量减１，一次 V 操作使信号量加１。 信号量主要用于进程或线程间的同步和互斥这两种典型情况。 信号量用于互斥： 信号量用...
【Linux】线程同步（条件变量）
xiaoxiaoguailou的博客
11-28 584
文章目录（一）条件变量（二）条件变量的相关接口（三）简单使用条件变量 （一）条件变量 条件变量提供一种线程间通知机制，当某个共享数据到达一定条件时，会唤醒等待（阻塞的）得到这个共享数据的线程 条件变量与互斥锁结合使用，对临界区资源加锁进行控制的基础上，当条件变量满足条件，会唤醒该线程；执行完毕后解锁； （二）条件变量的相关接口 头文件： pthread.h （1）初始化条件变量 int pthread_cond_init(pthread_cond_t* cond, pthread_condattr_t*
Linux 线程间通信和同步
hw5230的博客
11-09 184
Linux 线程间通信和同步
linux线程间通信函数,Linux多线程通信及同步
weixin_33600376的博客
05-06 147
建立多任务模型，并用线程来实现符合POSIX标准的UNIX操作系统提供了线程的控制函数，如：线程的创建和终止、线程之间的互斥、线程之间的同步等。利用这些系统函数可以成功地模拟消息队列，来实现线程间数据共享和同步，以完成多任务的实时性。为成功地描述线程间数据共享和同步，以下列任务模型为例。首先建立消息队列属性数据结构#define MAXQUEUE 30typedef struct mq_attri...
无名信号量
aLingYun的博客
10-30 464
信号量广泛用于进程或线程间的同步和互斥（一般用于线程，进程间常用有名管道），信号量本质上是一个非负的整数计数器，它被用来控制对公共资源的访问。编程时可根据操作信号量值的结果判断是否对公共资源具有访问的权限，当信号量值大于 0 时，则可以访问，否则将阻塞。PV 原语是对信号量的操作，一次 P 操作使信号量减１，一次 V 操作使信号量加１。 用于进程或线程间互斥： 初始化信号量为1； 执行需要互...
linux线程间通信及同步机制总结
duhui75的博客
12-15 390
线程间的通信有两种情况： 1、一个进程中的线程与另外一个进程中的线程通信，由于两个线程只能访问自己所属进程的地址空间和资源，故等同于进程间的通信。 2、同一个进程中的两个线程进行通信。 本文说的就是第二种情况。 关于进程间通信（IPC）可以看我的另一篇博文http://blog.csdn.net/a987073381/article/details/52006729 比起进程复杂的通信机制（管道、匿名管道、消息队列、信号量、共享内存、内存映射以及socket等），线程间通信要简单...
使用POSIX条件变量与互斥锁解决生产者-消费者同步
"这篇大作业关注的是在操作系统中如何实现生产者消费者同步问题，主要使用POSIX条件变量和互斥锁。目标是让学生理解和掌握操作系统中的同步机制，特别是互斥锁和条件变量的工作原理。实验内容包括在缓冲区为空时阻止...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

好好睡觉好好吃饭

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值