【Linux学习笔记】一篇文章彻底搞定 “Linux同步与互斥“ !

本章重点

  • 1. 学会线程同步。

  • 2 学会使用互斥量,条件变量,posix信号量,以及读写锁。

1、进程线程间的互斥相关背景概念

  • 临界资源:多线程执行流共享的资源就叫做临界资源
  • 临界区:每个线程内部,访问临界资源的代码,就叫做临界区
  • 互斥:任何时刻,互斥保证有且只有一个执行流进入临界区,访问临界资源,通常对临界资源起保护作用
  • 原子性(后面讨论如何实现):不会被任何调度机制打断的操作,该操作只有两态,要么完成,要么未完成

2、互斥量mutex

  • 大部分情况,线程使用的数据都是局部变量,变量的地址空间在线程栈空间内,这种情况,变量归属单个线程,其他线程无法获得这种变量。
  • 但有时候,很多变量都需要在线程间共享,这样的变量称为共享变量,可以通过数据的共享,完成线程之间的交互。
  • 多个线程并发的操作共享变量,会带来一些问题。

前一章我们提到了如果我们定义一个全局变量,所以的线程都可以访问并修改这个全局变量,所以我们把这个全局变量称为共享资源,未来这个共享资源被多线程并发访问的时候,此时我们的一个线程正在访问这个全局变量,而另外一个线程在修改这个全局变量,此时我们就会出现数据不一致的问题,不废话,我们来模拟一下。

#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <cstdlib>
#include <string>
#include <thread>
#include <vector>
#include <stdio.h>
#include <cstring>using namespace std;
#define NUM 4int tickets = 1000; // 用多线程,模拟一轮抢票class threadData
{
public:threadData(int number): _threadname("thread-" + to_string(number)){}public:string _threadname;
};void* getTicket(void* args)
{threadData* td = static_cast<threadData*>(args);const char* name = td->_threadname.c_str(); while(true){if(tickets > 0) //可以抢票{usleep(1000); printf("who = %s, get a ticket: %d\n", name, tickets);tickets--; //每抢到一张票,总量减一}elsebreak;}printf("%s ... quit\n", name);return nullptr;
}int main()
{vector<pthread_t> tids;vector<threadData*> thread_datas;for (int i = 1; i <= NUM; i++){pthread_t tid;threadData* td = new threadData(i);//给线程起名字thread_datas.push_back(td);pthread_create(&tid, nullptr, getTicket, thread_datas[i - 1]);tids.push_back(tid);}for(auto thread: tids)// 等待所有线程{pthread_join(thread, nullptr);}for(auto td : thread_datas){delete td;}return 0;
}

然后我们来运行一下:

我们发现此时票都为负数了,我们居然还能抢到票,哇,要是这样我们买电影票肯定不会买不到。哈哈哈,回顾本题,我们的代码是大于0才会抢票,为什么这里负数,还是可以抢票呢?我们上面提到了tickets这是一个可以被并发访问的共享资源,可以被所有的线程访问和修改,此时数据在无保护的情况下,被多线程并发访问,造成了数据不一致的问题!此时肯定和多线程并发访问是有关系的!我先来看一下数据计算的一般过程。

取出ticket--部分的汇编代码

objdump -d a.out > test.objdump
152 40064b: 8b 05 e3 04 20 00 mov 0x2004e3(%rip),%eax # 600b34
153 400651: 83 e8 01 sub $0x1,%eax
154 400654: 89 05 da 04 20 00 mov %eax,0x2004da(%rip) # 600b34

-- 操作并不是原子操作,而是对应三条汇编指令:

  • load :将共享变量ticket从内存加载到寄存器中
  • update : 更新寄存器里面的值,执行-1操作
  • store :将新值,从寄存器写回共享变量ticket的内存地址

为什么可能无法获得争取结果?

  • if 语句判断条件为真以后,代码可以并发的切换到其他线程
  • usleep 这个模拟漫长业务的过程,在这个漫长的业务过程中,可能有很多个线程会进入该代码段
  • --ticket 操作本身就不是一个原子操作

那么这个问题怎么解决呢?

对共享数据的任何访问,保证任何时候只有一个执行流访问!--- 互斥!!!

  • 代码必须要有互斥行为:当代码进入临界区执行时,不允许其他线程进入该临界区。
  • 如果多个线程同时要求执行临界区的代码,并且临界区没有线程在执行,那么只能允许一个线程进入该临 界区。
  • 如果线程不在临界区中执行,那么该线程不能阻止其他线程进入临界区。

要做到这三点,本质上就是需要一把锁。Linux上提供的这把锁叫互斥量。

3、互斥量的接口

初始化互斥量

初始化互斥量有两种方法:

方法1,静态分配:

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER

⭐方法2,动态分配:

int pthread_mutex_init(pthread_mutex_t *restrict mutex, 
const pthread_mutexattr_t *restrictattr);
参数:
mutex:要初始化的互斥量
attr:锁的相关属性,可以设置为NULL

销毁互斥量

销毁互斥量需要注意:

  • 使用 PTHREAD_ MUTEX_ INITIALIZER 初始化的互斥量不需要销毁
  • 不要销毁一个已经加锁的互斥量
  • 已经销毁的互斥量,要确保后面不会有线程再尝试加锁
int pthread_mutex_destroy(pthread_mutex_t *mutex);

互斥量加锁和解锁

int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
返回值:成功返回0,失败返回错误号

调用 pthread_ lock 时,可能会遇到以下情况:

  • 互斥量处于未锁状态,该函数会将互斥量锁定,同时返回成功
  • 发起函数调用时,其他线程已经锁定互斥量,或者存在其他线程同时申请互斥量,但没有竞争到互斥量, 那么pthread_ lock调用会陷入阻塞(执行流被挂起),等待互斥量解锁。

接下来我们来使用一下锁,看看下面的代码有什么问题?

此时票只能被一个线程所抢到,线程因为一直执行到票完为止。

此时若if条件不满足,此时执行break,锁资源就一直得不到释放,导致其他线程一直申请不到锁资源。

这样我们就能解决,随后验证一下抢票,改进上面的抢票系统

#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <cstdlib>
#include <string>
#include <thread>
#include <vector>
#include <stdio.h>
#include <cstring>using namespace std;
#define NUM 4int tickets = 1000; // 用多线程,模拟一轮抢票class threadData
{
public:threadData(int number, pthread_mutex_t* lock): _threadname("thread-" + to_string(number)), _lock(lock){}public:string _threadname;pthread_mutex_t* _lock;
};void* getTicket(void* args)
{threadData* td = static_cast<threadData*>(args);const char* name = td->_threadname.c_str(); while(true){// tickets - 共享资源 - 临界资源// 访问临界资源的代码 - 临界区pthread_mutex_lock(td->_lock);//加锁// 申请锁成功,才能往后执行,不成功,阻塞等待if(tickets > 0) //可以抢票{usleep(1000); printf("who = %s, get a ticket: %d\n", name, tickets);tickets--; //每抢到一张票,总量减一pthread_mutex_unlock(td->_lock);//解锁}else{pthread_mutex_unlock(td->_lock);//解锁break;}}  printf("%s ... quit\n", name);return nullptr;
}int main()
{pthread_mutex_t lock; // 锁 - main函数栈上开辟的空间pthread_mutex_init(&lock, nullptr);// 初始化锁vector<pthread_t> tids;vector<threadData*> thread_datas;for (int i = 1; i <= NUM; i++){pthread_t tid;// 让每个线程都拿到这把锁threadData* td = new threadData(i, &lock);//给线程起名字thread_datas.push_back(td);pthread_create(&tid, nullptr, getTicket, thread_datas[i - 1]);tids.push_back(tid);}for(auto thread: tids)// 等待所有线程{pthread_join(thread, nullptr);}for(auto td : thread_datas){delete td;}// 释放锁pthread_mutex_destroy(&lock);return 0;
}

看看运行结果:

此时我们确实解决了票数为负数的问题,可是为什么票都被thread-1抢去了,难道它是强盗吗?我们先将票数再改大一点,改到十万张,然后将输出结果写到文件里。

./mythread > log.txt   #重定向到log.txt文件中

此时文件比较大,我直接说结果了,此时依然只有一个线程抢到所有票,其他线程一张票都没有抢到,我们来修改一下代码的逻辑。

此时看到就运行成功了,上面的结果一直是一个线程抢票,是因为它离锁资源最近,抢锁速度非常快,导致其他线程抢不到,加上usleep就是让其他线程也能抢到锁,我们抢到票,我们并不会立马抢下一张票,其实在多线程还要执行抢票之后的后续动作,我们这里就是用usleep来模拟抢票之后的后续动作,然后我们再基于下面的图片理解一下上面的情况,同时再理解一些概念。

随后我们来使用第二种方式,定义一个全局的锁。

#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <cstdlib>
#include <string>
#include <thread>
#include <vector>
#include <stdio.h>
#include <cstring>using namespace std;#define NUM 4pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
int tickets = 1000; // 用多线程,模拟一轮抢票class threadData
{
public:threadData(int number): _threadname("thread-" + to_string(number)){}
public:string _threadname;
};void* getTicket(void* args)
{threadData* td = static_cast<threadData*>(args);const char* name = td->_threadname.c_str(); while(true){// tickets - 共享资源 - 临界资源// 访问临界资源的代码 - 临界区pthread_mutex_lock(&lock);//加锁// 申请锁成功,才能往后执行,不成功,阻塞等待if(tickets > 0) //可以抢票{usleep(1000); printf("who = %s, get a ticket: %d\n", name, tickets);tickets--; //每抢到一张票,总量减一pthread_mutex_unlock(&lock);//解锁}else{pthread_mutex_unlock(&lock);//解锁break;}usleep(10);  //新加}  printf("%s ... quit\n", name);return nullptr;
}int main()
{pthread_mutex_t lock; // 锁 - main函数栈上开辟的空间pthread_mutex_init(&lock, nullptr);// 初始化锁vector<pthread_t> tids;vector<threadData*> thread_datas;for (int i = 1; i <= NUM; i++){pthread_t tid;// 让每个线程都拿到这把锁threadData* td = new threadData(i);//给线程起名字thread_datas.push_back(td);pthread_create(&tid, nullptr, getTicket, thread_datas[i - 1]);tids.push_back(tid);}for(auto thread: tids)// 等待所有线程{pthread_join(thread, nullptr);}for(auto td : thread_datas){delete td;}// 释放锁pthread_mutex_destroy(&lock);return 0;
}

4、互斥量实现原理探究

申请锁和释放锁本身就被设计成为了原子性操作,如何做到的?

我们再来深入探讨一下,首先我们需要有一个共识

  • 经过上面的例子,大家已经意识到单纯的 i++ 或者 ++i 都不是原子的,有可能会有数据一致性问题
  • 为了实现互斥锁操作,大多数体系结构都提供了swap或exchange指令,该指令的作用是把寄存器和内存单元的数据相交换,由于只有一条指令,保证了原子性,即使是多处理器平台,访问内存的总线周期也有先后,一 个处理器上的交换指令执行时另一个处理器的交换指令只能等待总线周期。 现在我们把lock和unlock的伪代码看一下

现在我们再来对我们上面的抢票进行封装,更加深入理解锁

makefile

mythread:mythread.ccg++ -o $@ $^ -std=c++11 -lpthread
.PHONY:clean
clean:rm -f mythread

LockGuard.hpp

#pragma once#include <pthread.h>class Mutex
{
public:Mutex(pthread_mutex_t* lock): _lock(lock){}void Lock(){pthread_mutex_lock(_lock);}void Unlock(){pthread_mutex_unlock(_lock);}~Mutex(){}
private:pthread_mutex_t* _lock;
};class LockGuard
{
public:LockGuard(pthread_mutex_t* lock): _mutex(lock) //此时对象以及存在{_mutex.Lock();}~LockGuard() {_mutex.Unlock();}
private:Mutex _mutex;
};

mythread.cc

#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <cstdlib>
#include <string>
#include <thread>
#include <vector>
#include <stdio.h>
#include <cstring>
#include "LockGuard.hpp"using namespace std;
#define NUM 4int tickets = 1000; // 用多线程,模拟一轮抢票
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;//全局锁class threadData
{
public:threadData(int number): _threadname("thread-" + to_string(number)){}
public:string _threadname;
};void* getTicket(void* args)
{threadData* td = static_cast<threadData*>(args);const char* name = td->_threadname.c_str(); while(true){{// tickets - 共享资源 - 临界资源// 访问临界资源的代码 - 临界区// 申请锁成功,才能往后执行,不成功,阻塞等待LockGuard lockguard(&lock); // 临时的LockGuard对象,RAII风格的锁if(tickets > 0) //可以抢票{usleep(1000); printf("who = %s, get a ticket: %d\n", name, tickets);tickets--; //每抢到一张票,总量减一}else{break;}// 临时的LockGuard对象除出了作用域就会调用析构函数去释放锁}usleep(10);  //让这个不要成为临界区}  printf("%s ... quit\n", name);return nullptr;
}int main()
{pthread_mutex_t lock; // 锁 - main函数栈上开辟的空间pthread_mutex_init(&lock, nullptr);// 初始化锁vector<pthread_t> tids;vector<threadData*> thread_datas;for (int i = 1; i <= NUM; i++){pthread_t tid;// 让每个线程都拿到这把锁threadData* td = new threadData(i);//给线程起名字thread_datas.push_back(td);pthread_create(&tid, nullptr, getTicket, thread_datas[i - 1]);tids.push_back(tid);}for(auto thread: tids)// 等待所有线程{pthread_join(thread, nullptr);}for(auto td : thread_datas){delete td;}// 释放锁pthread_mutex_destroy(&lock);return 0;
}

5、可重入VS线程安全

概念:

  • 线程安全:多个线程并发同一段代码时,不会出现不同的结果。常见对全局变量或者静态变量进行操作, 并且没有锁保护的情况下,会出现该问题。
  • 重入:同一个函数被不同的执行流调用,当前一个流程还没有执行完,就有其他的执行流再次进入,我们称之为重入。一个函数在重入的情况下,运行结果不会出现任何不同或者任何问题,则该函数被称为可重入函数,否则,是不可重入函数。

常见的线程不安全的情况

  • 不保护共享变量的函数
  • 函数状态随着被调用,状态发生变化的函数
  • 返回指向静态变量指针的函数
  • 调用线程不安全函数的函数

常见的线程安全的情况

  • 每个线程对全局变量或者静态变量只有读取的权限,而没有写入的权限,一般来说这些线程是安全的
  • 类或者接口对于线程来说都是原子操作
  • 多个线程之间的切换不会导致该接口的执行结果存在二义性

常见不可重入的情况

  • 调用了malloc/free函数,因为malloc函数是用全局链表来管理堆的
  • 调用了标准I/O库函数,标准I/O库的很多实现都以不可重入的方式使用全局数据结构
  • 可重入函数体内使用了静态的数据结构

常见可重入的情况

  • 不使用全局变量或静态变量
  • 不使用用malloc或者new开辟出的空间
  • 不调用不可重入函数
  • 不返回静态或全局数据,所有数据都有函数的调用者提供
  • 使用本地数据,或者通过制作全局数据的本地拷贝来保护全局数据

可重入与线程安全联系

  • 函数是可重入的,那就是线程安全的
  • 函数是不可重入的,那就不能由多个线程使用,有可能引发线程安全问题
  • 如果一个函数中有全局变量,那么这个函数既不是线程安全也不是可重入的。

可重入与线程安全区别

  • 可重入函数是线程安全函数的一种
  • 线程安全不一定是可重入的,而可重入函数则一定是线程安全的。
  • 如果将对临界资源的访问加上锁,则这个函数是线程安全的,但如果这个重入函数若锁还未释放则会产生死锁,因此是不可重入的。

总结一下:

线程安全描述的是线程并发的问题,可重入描述的是函数的特点。

⭐不可重入函数,在多线程访问可能会出现线程安全的问题,但是一个函数可重入,那么不会出现线程问题。

6. 常见锁概念

⭐死锁:死锁是指在一组进程中的各个进程均占有不会释放的资源,但因互相申请被其他进程所占用不会释放的资源而处于的一种永久等待状态,直接代码案例演示现象。

此时线程拿着锁锁资源然后再去申请锁资源,但是没有线程释放锁资源,从而导致所有线程申请锁资源都不成功,所以整个线程全部都卡住了,这就是一个典型的死锁场景。

死锁四个必要条件

⭐必要条件:如果产生了死锁的问题,那么下面的四个条件必须都要满足。

  • 互斥条件:一个资源每次只能被一个执行流使用(前提)
  • 请求与保持条件:一个执行流因请求资源而阻塞时,对已获得的资源保持不放(原则)
  • 不剥夺条件:一个执行流已获得的资源,在末使用完之前,不能强行剥夺(原则)
  • 循环等待条件:若干执行流之间形成一种头尾相接的循环等待资源的关系(重要条件)

避免死锁

  • 破坏死锁的四个必要条件
  • 加锁顺序一致
  • 避免锁未释放的场景
  • 资源一次性分配

避免死锁算法

⭐死锁检测算法

⭐银行家算法

7、Linux线程同步

同步:同步问题是保证数据安全的情况下,让我们的线程访问资源具有一定的顺序性。

条件变量

条件变量必须依赖于锁的使用

  • 当一个线程互斥地访问某个变量时,它可能发现在其它线程改变状态之前,它什么也做不了。
  • 例如一个线程访问队列时,发现队列为空,它只能等待,只到其它线程将一个节点添加到队列中。这种情况就需要用到条件变量。

同步概念与竞态条件

  • 同步:在保证数据安全的前提下,让线程能够按照某种特定的顺序访问临界资源,从而有效避免饥饿问 题,叫做同步
  • 竞态条件:因为时序问题,而导致程序异常,我们称之为竞态条件。在线程场景下,这种问题也不难理解

条件变量函数

初始化

int pthread_cond_init(pthread_cond_t *restrict cond,
const pthread_condattr_t *restrictattr);
参数:
cond:要初始化的条件变量
attr:NULL

销毁

int pthread_cond_destroy(pthread_cond_t *cond)

等待条件满足

int pthread_cond_wait(pthread_cond_t *restrict cond,
pthread_mutex_t *restrict mutex);
参数:
cond:要在这个条件变量上等待
mutex:互斥量,后面详细解释

唤醒等待

int pthread_cond_broadcast(pthread_cond_t *cond);//唤醒所有线程
int pthread_cond_signal(pthread_cond_t *cond);//唤醒最近的一个线程
#include <iostream>
#include <pthread.h>
#include <unistd.h>using namespace std;int cnt = 0;void* Count(void* args)
{pthread_detach(pthread_self()); //分离进程uint64_t number = (uint64_t)args;while(true){cout << "pthread: " << number << endl;sleep(3);}
}int main()
{for(uint64_t i = 0; i < 5; i++){   pthread_t tid;pthread_create(&tid, nullptr, Count, (void*)i);// 注意,这里不能传入&i,因为此时传过去拿到的是i的地址,// 如果从线程解引用到&i,就可以修改i的值,从而影响主线程的逻辑}while(true) sleep(1);return 0;
}

此时我们来看一下结果:

我们也可以看一下如果传入的是i的地址结果是怎么样的。

#include <iostream>
#include <pthread.h>
#include <unistd.h>using namespace std;int cnt = 0;void* Count(void* args)
{pthread_detach(pthread_self()); //分离进程uint64_t number = *(uint64_t*)args;while(true){cout << "pthread: " << number << endl;sleep(3);}
}int main()
{for(uint64_t i = 0; i < 5; i++){   pthread_t tid;pthread_create(&tid, nullptr, Count, (void*)&i);// 注意,这里不能传入&i,因为此时传过去拿到的是i的地址,// 如果从线程解引用到&i,就可以修改i的值,从而影响主线程的逻辑}while(true) sleep(1);return 0;
}

看看运行结果:

此时就会出现意外的情况,所有不能传入i的地址。

#include <iostream>
#include <pthread.h>
#include <unistd.h>using namespace std;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER; 
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int cnt = 0;void* Count(void* args)
{pthread_detach(pthread_self()); //分离进程uint64_t number = (uint64_t)args;while(true){pthread_mutex_lock(&lock);// 这里要注意除了我们的cnt是临界资源,我们的显示器也是临界资源哟!// 同一个时间内,存在多个线程想向显示器写入内容cout << "pthread: " << number << ", cnt: " << cnt++ << endl;pthread_mutex_unlock(&lock);}
}int main()
{for(uint64_t i = 0; i < 5; i++){   pthread_t tid;pthread_create(&tid, nullptr, Count, (void*)i);// 注意,这里不能传入&i,因为此时传过去拿到的是i的地址,// 如果从线程解引用到&i,就可以修改i的值,从而影响主线程的逻辑}while(true) sleep(1);return 0;
}

此时就和我们的抢票一样,线程5一个人占用锁资源,其他线程根本抢不到,所以此时我们就要使用条件变量,不要让线程一直占有锁。

#include <iostream>
#include <pthread.h>
#include <unistd.h>using namespace std;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER; 
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int cnt = 0;void* Count(void* args)
{pthread_detach(pthread_self()); //分离进程uint64_t number = (uint64_t)args;cout << "pthread: " << number << " creat success" << endl;while(true){pthread_mutex_lock(&lock);// 这里要注意除了我们的cnt是临界资源,我们的显示器也是临界资源哟!// 同一个时间内,存在多个线程想向显示器写入内容// 不管临界资源的状态情况//?为什么在这里 1.pthread_cond_wait让线程等待的时候,会自动释放锁!// 所有线程一申请锁,立马释放锁并去排队pthread_cond_wait(&cond, &lock); cout << "pthread: " << number << ", cnt: " << cnt++ << endl;pthread_mutex_unlock(&lock);}
}int main()
{for(uint64_t i = 0; i < 5; i++){   pthread_t tid;pthread_create(&tid, nullptr, Count, (void*)i);// 注意,这里不能传入&i,因为此时传过去拿到的是i的地址,// 如果从线程解引用到&i,就可以修改i的值,从而影响主线程的逻辑}sleep(3);// 保证所有线程都已经在队列排队cout << "main thread ctrl begin: " << endl;// 主线程来唤醒while(true){sleep(1);// 唤醒指定条件变量下的等待队列的一个线程,默认都是第一个pthread_cond_signal(&cond);cout << "signal one thread..." << endl;}return 0;
}

运行结果:

此时我们就能看到所有的线程能按照一定的次序来得到锁资源,我们再来使用一下唤醒一批线程的接口。

细节问题:为什么线程等待在线程加锁之后???

这里我们就要详细解释一下,就拿我们的抢票来说,我们抢到了锁不一定就能成功抢到票,你肯定此时要有票吧,没有票资源你抢到了锁也只能干等着,所以线程等待必须在线程加锁之后,因为判断临界资源是否满足,也是在访问临界资源!判断资源是否就绪(也就是还有没有票),是通过在临界资源内部实现的,此时当资源没有就绪(也就是没有票了),那么你肯定要等待工作人员发票,你肯定就要等待,可是你不要忘了,此时你是带锁等待的哟!未来票资源准备好了有锁你就能买票,但是此时你直接带锁去等待前面的线程锁的释放,但是别的线程都没有申请到锁你怎么让它释放锁呢?,导致其他线程无法申请锁,其他人也都在等,所以此时程序阻塞了,所以设计条件变量的人也想到了这个问题,它就将pthread_cond_wait的时候,会自动释放锁,当未来唤醒返回的时候,我们一定是重新申请了锁。

细节问题:为什么 pthread_cond_wait 需要互斥量?

  • 条件等待是线程间同步的一种手段,如果只有一个线程,条件不满足,一直等下去都不会满足,所以必须 要有一个线程通过某些操作,改变共享变量,使原先不满足的条件变得满足,并且友好的通知等待在条件 变量上的线程。
  • 条件不会无缘无故的突然变得满足了,必然会牵扯到共享数据的变化。所以一定要用互斥锁来保护。没有 互斥锁就无法安全的获取和修改共享数据。

按照上面的说法,我们设计出如下的代码:先上锁,发现条件不满足,解锁,然后等待在条件变量上不就行了,如下代码:

// 错误的设计 
pthread_mutex_lock(&mutex);
while (condition_is_false) {pthread_mutex_unlock(&mutex);//解锁之后,等待之前,条件可能已经满足,信号已经发出,但是该信号可能被错过 pthread_cond_wait(&cond);pthread_mutex_lock(&mutex);
}
pthread_mutex_unlock(&mutex);
  • 由于解锁和等待不是原子操作。调用解锁之后, pthread_cond_wait 之前,如果已经有其他线程获取到 互斥量,摒弃条件满足,发送了信号,那么 pthread_cond_wait 将错过这个信号,可能会导致线程永远 阻塞在这个 pthread_cond_wait 。所以解锁和等待必须是一个原子操作。
  • int pthread_cond_wait(pthread_cond_ t *cond,pthread_mutex_ t * mutex); 进入该函数后, 会去看条件量等于0不?等于,就把互斥量变成1,直到cond_ wait返回,把条件量改成1,把互斥量恢复 成原样。

条件变量使用规范

等待条件代码

pthread_mutex_lock(&mutex);
while (条件为假)pthread_cond_wait(cond, mutex);
修改条件
pthread_mutex_unlock(&mutex);

⭐给条件发送信号代码

pthread_mutex_lock(&mutex);
设置条件为真
pthread_cond_signal(cond);
pthread_mutex_unlock(&mutex);

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/diannao/11278.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

JavaSE继承

1、继承 关键字&#xff1a;extends 继承的作用&#xff1a;多态前提条件&#xff0c;提高代码复用率 继承的缺点&#xff1a; 父类中私有的属性和方法&#xff0c;子类是无法使用的 在java中只支持单继承&#xff0c;不支持多继承&#xff0c;但是可以支持多重继承 继承后…

Sylar C++高性能服务器学习记录12 【IO调度模块-代码分析篇】

早在19年5月就在某站上看到sylar的视频了&#xff0c;一直认为这是一个非常不错的视频。 由于本人一直是自学编程&#xff0c;基础不扎实&#xff0c;也没有任何人的督促&#xff0c;没能坚持下去。 每每想起倍感惋惜&#xff0c;遂提笔再续前缘。 为了能更好的看懂sylar&…

【多电压流程 Multivoltage Flow】- 5.特定工具使用建议(5.使用ICC II以及FC进行物理实现)

使用IC Compiler II和Fusion Compiler进行物理实现 在完成带有行站点、电源规划和I/O放置的floorplan之后,可以继续进行物理综合和实现。Fusion Compiler提供了广泛的功能,以执行设计的平面物理实现。 图67显示了物理实现流程的一般步骤以及流程的低功耗支持特性。 图67 I…

Elasticsearch框架学习的难点和重点有哪些

Elasticsearch是一个基于Lucene构建的开源搜索引擎&#xff0c;广泛用于全文检索、日志数据分析等多种应用场景。由于其强大的搜索能力、灵活的扩展性和丰富的功能特性&#xff0c;Elasticsearch在数据分析和搜索领域非常受欢迎。V哥认为学习Elasticsearch主要包括以下几个难点…

极度内卷,消费下行,AIGC如何成为普通人易变现好上手的新机会,这几种方法一定要尝试!

最近看到一个麦肯锡报告&#xff0c;说到2030年&#xff0c;AI会替代1亿多中国人的岗位。 暂且不说这个预测是否准确&#xff0c;但自从AI横空出世&#xff0c;确实给我们的生活带来了翻天覆地的变化&#xff0c;有人顺势起飞&#xff0c;有人被时代淘汰… 李开复也曾不止一次…

47-Qt控件详解:Buttons Containers1

一 QPushButton (命令按钮) #ifndef MAINWINDOW_H #define MAINWINDOW_H#include <QMainWindow> #include <QPushButton>//引入QPushButton类对应的头文件class MainWindow : public QMainWindow {Q_OBJECTpublic:MainWindow(QWidget *parent nullptr);~MainWind…

如何评估大型语言模型(LLM)?

01 简介 Introduction 随着ChatGPT和其他大型语言模型&#xff08;LLMs&#xff09;的发布&#xff0c;可用模型数量大量增加&#xff0c;现在几乎每天都有新的LLMs发布。尽管如此&#xff0c;当下仍然没有一个通用的标准来评估这些大型语言模型的质量。本文将回顾现有的大型语…

振弦式表面式应变计有哪些功能优势

振弦式表面应变计是一种高精度的测量工具&#xff0c;专门用于测量材料表面的应变和位移。它通过监测材料表面的微小变化&#xff0c;帮助工程师获得关键的结构性能数据。振弦式表面应变计因其独特的功能优势&#xff0c;在众多领域尤其是在结构健康监测中&#xff0c;发挥着不…

卡尔曼滤波状态估计

clear all; close all; clc; %% 上面是调用卡尔曼滤波 % 定义状态维数和初始条件 n 3; % 状态维数 q 0.2; % 过程噪声标准差 r 0.15; % 测量噪声标准差 Q q * eye(n); …

vite配置别名@时遇到错误【Dynamic require of “path“ is not supported 】

遇到的问题 vite项目中配置别名的时候&#xff0c;使用 const path require("path") 的形式引入path的时候提示错误&#xff1a; failed to load config from C:\Users\Administrator\Desktop\zss\note\demo\demo\vite.config.js 10:30:31 [vite] Dynamic require…

Oracle如何收缩减小表空间大小

比如我们发现一个表空间占用比较大&#xff0c;但是空闲空间很大&#xff0c;想要减小表空间占用大小。查看表空间的情况 发现BETEST表空间占用大&#xff0c;但是剩余大小比较大&#xff0c;可以减小存储占用。 如果我们想减小到100MB&#xff0c;那么就登录其用户执行&#…

UDP怎么端口映射?

在网络通信中&#xff0c;TCP和UDP是两种常用的传输协议。UDP&#xff08;User Datagram Protocol&#xff09;是一种无连接的传输协议&#xff0c;相较于TCP协议来说&#xff0c;它更为轻量级且不可靠。UDP协议在某些场景下仍然有其独特的优势&#xff0c;尤其是在需要快速传输…

足球知识付费系统下载,教育后半场,创业公司如何突围?

伴随着资本寒冬&#xff0c;企业用人成本高企&#xff0c;市场竞争环境半垄断半割据&#xff0c;“找人、找钱、找方向”对于初创企业来说无疑都难上加难。 在这种环境下&#xff0c;北极光创投创始人、董事总经理邓锋说&#xff1a;虽然面临诸多挑战&#xff0c;但相信新的机会…

每天一个数据分析题(三百一十二)-业务分析模型

理解业务分析模型能够更好的把握业务全局&#xff0c;以下可以用来对产品分类的模型是&#xff1f; A. RFM模型 B. 用户贡献价值模型 C. 波士顿矩阵 D. 销售漏斗模型 数据分析认证考试介绍&#xff1a;点击进入 题目来源于CDA模拟题库 点击此处获取答案

高端手机格局再生变数,华为赋魅、苹果祛魅

历经二十多年发展&#xff0c;智能手机产业链高度成熟&#xff0c;消费者换机需求疲软&#xff0c;智能手机厂商艰难创新&#xff0c;市场存量竞争早已进入白热化阶段。 在消费侧&#xff0c;消费者换机周期不断延长&#xff0c;智能手机赛道进入增长疲软期。研究机构TechInsi…

JavaScript 工具函数(分享)

文章目录 1. 任意区间的的随机数2. 判断一个数是不是质数3. 传入指定 key 返回当前页面 search 的 value&#xff0c;也可以手动传入url4. 在 Date 上封装了一个返回指定格式的方法5. 数组去重6. 预览pdf&#xff0c;后端返回的文件流设置的只能下载&#xff0c;需要预览7. 下载…

速盾:jquery是用cdn快,还是保存本地快?

在讨论jQuery是使用CDN快还是保存本地快之前&#xff0c;我们先来了解一下jQuery是什么。 jQuery是一种流行的JavaScript库&#xff0c;它极大地简化了JavaScript编程&#xff0c;使得开发者能够更轻松地操作HTML文档、处理事件、实现动画效果以及处理AJAX请求。由于其简单易用…

Spring:Spring Boot常用注解大全

Spring Boot是一个由Pivotal团队提供的全新框架&#xff0c;其设计目的是用来简化新Spring应用的初始搭建以及开发过程。以下是对Spring Boot的详细介绍&#xff1a; 一、发展沿革   2013年&#xff0c;Pivotal团队开始研发Spring Boot。   2014年4月&#xff0c;发布了全…

各渠道应用推广点击上报文档地址

小米点击上报&#xff1a;https://api.e.mi.com/doc.html#/1.0.0-mdtag9b26f-omd/document-2bd1c4c260259b072818205a8ae20139 荣耀点击上报&#xff1a;https://ads.honor.com/help/1738095811504373761

python print用

Python中的print()函数是最常用的一个内置函数&#xff0c;用来向标准输出设备&#xff08;通常是屏幕&#xff09;发送文本或其他类型的对象。从Python初学者到高级开发人员&#xff0c;print()函数是编写程序时不可或缺的一个工具。本文旨在深入探讨print()函数的不同用法和技…