多线程编程--互斥锁、条件变量

最新推荐文章于 2024-09-11 21:20:09 发布
最新推荐文章于 2024-09-11 21:20:09 发布
阅读量452 收藏 1
点赞数 1
分类专栏： # 多线程编程 linux 文章标签： linux Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_58550520/article/details/129089176
版权

注：本文用于个人学习/复习，代码参考 互斥锁_哔哩哔哩_bilibili

1、线程同步

多个线程访问同一块共享资源，需要按照顺序依次执行访问，线程对内存的这种访问方式被称之为线程同步

实现线程同步有以下的几种方法：

互斥锁

条件变量

信号量

自旋锁

读写锁

2、互斥锁

1）初始化锁

int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutex_attr);

mutex_attr参数选择：
* PTHREAD_MUTEX_TIMED_NP，这是缺省值，也就是普通锁。当一个线程加锁以后，其余请求锁的线程将形成一个等待队列，并在解锁后按优先级获得锁。这种锁策略保证了资源分配的公平性。
* PTHREAD_MUTEX_RECURSIVE_NP，嵌套锁，允许同一个线程对同一个锁成功获得多次，并通过多次unlock解锁。如果是不同线程请求，则在加锁线程解锁时重新竞争。
* PTHREAD_MUTEX_ERRORCHECK_NP，检错锁，如果同一个线程请求同一个锁，则返回EDEADLK，否则与PTHREAD_MUTEX_TIMED_NP类型动作相同。这样保证当不允许多次加锁时不出现最简单情况下的死锁。
* PTHREAD_MUTEX_ADAPTIVE_NP，适应锁，动作最简单的锁类型，仅等待解锁后重新竞争。

或者定义互斥锁的时候直接使用下面语句对锁进行初始化：
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

2）阻塞加锁，若互斥锁已经被其他线程上锁，则调用者一直阻塞等待，直到被解锁后才上锁

int pthread_mutex_lock(pthread_mutex_t *mutex);

3）非阻塞加锁，若互斥锁未加锁，则上锁，若互斥锁已加锁，则函数立即返回失败

int pthread_mutex_trylock(pthread_mutex_t *mutex);

4）解锁

int pthread_mutex_unlock(pthread_mutex_t *mutex);

5）销毁锁，释放资源

int pthread_mutex_destroy(pthread_mutex_t *mutex);

互斥锁存在优先唤醒的过程

测试demo如下：

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>

using std::cout;
using std::endl;

char buffer[100];

pthread_mutex_t mutex;

void *callback(void *arg)
{
        for(int i = 0; i < 3; i++) {
                // cout << time(0) << ":  lock --- pthread " << (long)arg << endl;
                pthread_mutex_lock(&mutex);
                cout << time(0) << ":  lock --- pthread " << (long)arg << endl;

                sprintf(buffer, "%d:%ld,%d", time(0), pthread_self(), i);
                sleep(5);

                pthread_mutex_unlock(&mutex);
                cout << time(0) << ":  unlock ---pthread " << (long)arg << endl;
                
                usleep(100);
        }
}

int main()
{
        pthread_mutex_init(&mutex, NULL);

        pthread_t tid1, tid2;
        pthread_create(&tid1, NULL, callback, (void *)1);
        pthread_create(&tid2, NULL, callback, (void *)2);

        pthread_join(tid1, NULL);
        pthread_join(tid2, NULL);

        pthread_mutex_destroy(&mutex);

        return 0;
}

执行结果如下：

1676601133:  lock --- pthread 1
1676601138:  unlock ---pthread 1
1676601138:  lock --- pthread 2
1676601143:  unlock ---pthread 2
1676601143:  lock --- pthread 1
1676601148:  unlock ---pthread 1
1676601148:  lock --- pthread 2
1676601153:  unlock ---pthread 2
1676601153:  lock --- pthread 1
1676601158:  unlock ---pthread 1
1676601158:  lock --- pthread 2
1676601163:  unlock ---pthread 2

从测试log可以看出，各个线程逐个逐个访问全局变量buffer

3、条件变量

条件变量用来阻塞一个线程，直到其他的线程通知它条件已满足为止

条件变量看似简单，与互斥锁同时使用时非常巧妙

1）初始化条件变量

int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr);


或者定义条件变量的时候直接使用下面语句对条件变量进行初始化：
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

2）阻塞等待

int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);

3）超时等待

int pthread_cond_timewait(pthread_cond_t *cond, pthread_mutex_t *mutex, const timespec *abstime);

4）唤醒一个等待该条件的线程

int pthread_cond_signal(pthread_cond_t *cond);

5）唤醒所有等待该条件的所有线程

int pthread_cond_broadcast(pthread_cond_t *cond);

6）销毁条件变量

int pthread_cond_destroy(pthread_cond_t *cond);

测试demo：

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <signal.h>

using std::cout;
using std::endl;

pthread_mutex_t mutex;
pthread_cond_t cond;

void *callback1(void *arg)
{
        while(1) {
                pthread_cond_wait(&cond, &mutex);
                cout << "pthread 1 wake up!" << endl;
        }
}

void *callback2(void *arg)
{
        while(1) {
                pthread_cond_wait(&cond, &mutex);
                cout << "pthread 2 wake up!" << endl;
        }
}

void func(int sig)
{
        pthread_cond_signal(&cond);
        // pthread_cond_broadcast(&cond);
}

int main()
{
        signal(15, func);

        pthread_mutex_init(&mutex, NULL);
        pthread_cond_init(&cond, NULL);

        pthread_t tid1, tid2;
        pthread_create(&tid1, NULL, callback1, NULL);
        pthread_create(&tid2, NULL, callback2, NULL);

        pthread_join(tid1, NULL);
        pthread_join(tid2, NULL);

        pthread_mutex_destroy(&mutex);
        pthread_cond_destroy(&cond);

        return 0;
}

测试结果：

另外一个终端的输入：
killall -15 test2
killall -15 test2
killall -15 test2
killall -15 test2

输出：
pthread 1 wake up!
pthread 2 wake up!
pthread 1 wake up!
pthread 2 wake up!

如果将pthread_cond_signal函数注释，打开pthread_cond_broadcast函数的注释，就可以得到以下的结果：

另外一个终端的输入：
killall -15 test2
killall -15 test2
killall -15 test2
killall -15 test2

输出：
pthread 1 wake up!
pthread 2 wake up!
pthread 1 wake up!
pthread 2 wake up!
pthread 1 wake up!
pthread 2 wake up!
pthread 1 wake up!
pthread 2 wake up!

4、条件变量与互斥锁的关系

测试demo：

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <signal.h>

using std::cout;
using std::endl;

pthread_mutex_t mutex;
pthread_cond_t cond;

void *callback1(void *arg)
{
        while(1) {
                pthread_mutex_lock(&mutex);
                cout << "pthread 1 wait" << endl;
                pthread_cond_wait(&cond, &mutex);
                cout << "pthread 1 wake up!" << endl;
                pthread_mutex_unlock(&mutex);        
        }
}

void *callback2(void *arg)
{
        while(1) {
                pthread_mutex_lock(&mutex);
                cout << "pthread 2 wait" << endl;
                pthread_cond_wait(&cond, &mutex);
                cout << "pthread 2 wake up!" << endl;
                pthread_mutex_unlock(&mutex);        
        }
}

void func(int sig)
{
        pthread_cond_signal(&cond);
        // pthread_cond_broadcast(&cond);
}

int main()
{
        signal(15, func);

        pthread_mutex_init(&mutex, NULL);
        pthread_cond_init(&cond, NULL);

        pthread_t tid1, tid2;
        pthread_create(&tid1, NULL, callback1, NULL);
        pthread_create(&tid2, NULL, callback2, NULL);

        pthread_join(tid1, NULL);
        pthread_join(tid2, NULL);

        pthread_mutex_destroy(&mutex);
        pthread_cond_destroy(&cond);

        return 0;
}

执行结果如下：

另一个终端：
killall -15 test2
killall -15 test2
killall -15 test2
killall -15 test2

测试结果：
pthread 1 wait
pthread 2 wait
pthread 1 wake up!
pthread 1 wait
pthread 2 wake up!
pthread 2 wait
pthread 1 wake up!
pthread 1 wait
pthread 2 wake up!
pthread 2 wait

pthread_cond_wait函数里面发生了什么？

1）释放了互斥锁

pthread_cond_wait函数里面第二个参数是互斥锁

2）等待条件

3）条件被触发并且给互斥锁加锁

第三步是原子操作

reg_hua
关注
专栏目录
浅谈多线程同步01 --- --- 互斥锁、条件变量、信号量和读写锁
Boss_peng的博客
06-05 483
浅谈多线程同步01 --- --- 互斥锁、条件变量、信号量和读写锁
C多线程编程---互斥锁mutex
qq_23929673的博客
01-27 868
文章目录1、多线程的问题引入2、互斥锁1、初始化一个互斥锁：2、加锁：3、解锁：4、注销互斥锁：5、pthread_mutex_lock()和pthread_mutex_trylock()区别6、解锁要满足的条件： 1、多线程的问题引入 多线程的最大的特点是资源的共享，但是，当多个线程同时去操作（同时去改变）一个临界资源时，会破坏临界资源。如利用多线程同时写一个文件： #include <s...
多线程编程——互斥锁使用（Jack_pthread_mutex_test.rar）
08-19
多线程编程：互斥锁使用。 打包文件包含两个文件：c文件源代码、Makefile文件，运行环境在Ubuntu14.04下，使用自带的gcc编译器，同学们只需将文件夹复制到某一目录下之后在终端执行：1.“make”生成“test”可执行文件；2. 输入“./test”运行可执行程序，即可查看运行结果。
互斥锁和条件变量
weixin_34219944的博客
01-09 188
　　为了允许在线程或进程之间共享数据，同步时必须的，互斥锁和条件变量是同步的基本组成部分。 1、互斥锁 　　互斥锁是用来保护临界区资源，实际上保护的是临界区中被操纵的数据，互斥锁通常用于保护由多个线程或多进程分享的共享数据。一般是一些可供线程间使用的全局变量，来达到线程同步的目的,即保证任何时刻只有一个线程或进程在执行其中的代码。一般加锁的轮廓如下： pthread_mutex_lock...
C++ 互斥锁、条件变量的基础使用
最新发布
m0_64240990的博客
09-11 651
在C++多线程开发中，互斥锁和条件变量是线程同步中非常重要的部分。互斥锁和条件变量主要用于确保对共享资源的访问是线程安全的（C++的容器都不是线程安全的）。本文主要介绍互斥锁和条件变量的基础使用。
python多线程编程: 使用互斥锁同步线程
weixin_33854644的博客
04-17 165
2019独角兽企业重金招聘Python工程师标准>>> ...
互斥锁、条件变量
月雲之霄的博客
10-30 767
一、互斥锁 1. 函数原型： pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr); pthread_mutex_destroy(pthread_mutex_t *mutex); 分析： pthread_mutex_t 类型，其本质是一个结构体，...
互斥锁与条件变量
Hulk
04-23 306
互斥锁互斥锁用于保护临界区，使得任何时刻只有一个线程在执行其中的代码。确切的说，互斥锁用于保护多个线程或多个进程分享的共享数据。posix互斥锁被声明为具有pthread_mutex_t数据类型的变量。若互斥锁变量是静态分配的，则初始化为：    static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;若互斥锁变量是动态分配的（malloc）...
多线程并发编程-同步与互斥-原⼦变量-并发和⽆锁 数据结构
12-30
线程同步和互斥是多线程编程的核心技术之一。信号灯、互斥量、自旋锁和条件变量等都是实现线程同步和互斥的机制。线程同步和互斥的机制可以通过原子变量来实现。 5.3 线程同步和互斥 线程同步和互斥是多线程编程的...
Linux C 多线程编程之互斥锁与条件变量实例详解
07-14
一、互斥锁 互斥量从本质上说就是一把锁, 提供对共享资源的保护访问。 1. 初始化: 在Linux下, 线程的互斥量数据类型是pthread_mutex_t. 在使用前, 要对它进行初始化: 对于静态分配的互斥量, 可以把它设置为...
android 线程互斥锁,多线程编程-互斥锁
weixin_27127993的博客
05-29 917
1．引言：互斥锁，是一种信号量，常用来防止两个进程或线程在同一时刻访问相同的共享资源。可以保证以下三点：原子性：把一个互斥量锁定为一个原子操作，这意味着操作系统(或pthread函数库)保证了如果一个线程锁定了一个互斥量，没有其他线程在同一时间可以成功锁定这个互斥量。唯一性：如果一个线程锁定了一个互斥量，在它解除锁定之前，没有其他线程可以锁定这个互斥量。非繁忙等待：如果一个线程已经锁定了一个互斥量...
互斥锁和条件变量【原创总结】
张继飞的专栏
03-20 182
Author：张继飞 鉴于最近在网上回到很多网友关于线程使用，以及互斥锁的问题和条件变量使用的问题，现总结一下基本用法，以后用的时候方便查找。　　 一、互斥锁 互斥量从本质上说就是一把锁, 提供对共享资源的保护访问。 　　1. 初始化: 　　在Linux下, 线程的互斥量数据类型是pthread_mutex_t. 在使用前, 要对它进行初始化: 　　对于静态分配的互斥量, 可以把...
线程间的互斥锁和条件变量
m0_70888041的博客
01-05 355
而条件变量通过允许线程阻塞和等待另一个线程放松信号的方法弥补了互斥锁的不足，它常和互斥锁一块使用。使用时，条件变量被用来阻塞一个线程，当条件不满足时，线程往往解开相应的互斥锁并等待条件发生变化。一旦其他的某个线程改变了条件变量，它将通知相应的条件变量唤醒一个或多个正在被此条件阻塞的线程。pthread_cond_wait函数的返回并不意味着条件的值一定发生了变化，必须重新检查条件的值。若其他线程希望对一个已经上了锁的互斥锁上锁，则该线程会被挂起，直到上锁的线程释放掉互斥锁为止。某鱼上买估计至少要好几十。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值