【C++ 语言】线程安全队列 ( 条件变量 | 线程调度 )

最新推荐文章于 2024-07-18 23:49:25 发布
最新推荐文章于 2024-07-18 23:49:25 发布
阅读量1.2k 收藏 6
点赞数 2
分类专栏： C++ 文章标签： 条件变量 线程调度 C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-NC-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shulianghan/article/details/102851323
版权
C++ 专栏收录该内容
250 篇文章 188 订阅
订阅专栏

文章目录



I . 线程简单使用

线程简单使用流程 :


① 线程方法准备 : 定义一个方法 , 主要使用其 方法名称 和 返回值 ;

//线程的主方法 , 类似于 Java 中的 run 方法 , C++ 中方法名随意
void* pushData(void*) {
	// ... 
}

② 声明线程 ID : 线程 ID 类型是 pthread_t 类型的 , 其本质是 int 类型 ;

pthread_t pid_push;

③ 创建线程并执行 : pthread_create() 方法时创建并启动线程 ;

//启动一个线程 , 无限循环 向线程安全队列中存储数据
pthread_create(&pid_push, 0, pushData, 0);

该方法需要提供四个参数 :

  • 参数 1 ( pthread_t *tidp ) :线程标识符指针 , 该指针指向线程标识符 ;
  • 参数 2 ( const pthread_attr_t *attr ) : 线程属性指针 ;
  • 参数 3 ( (void*)(*start_rtn)(void*) ) : 线程运行函数指针 , start_rtn 是一个函数指针 , 其参数和返回值类型是 void* 类型
  • 参数 4 ( void *arg ) : 参数 3 中的线程运行函数的参数 ;

④ 等待线程执行完毕 : pthread_join (pthread_t thread, void **value_ptr)方法 , 等待 thread 线程 ID 代表的线程执行完毕 ;

//阻塞 , 等待其中任意一个线程执行完毕 , 实际上是一直在此阻塞 , 如果运行下去 主函数就暂停了
pthread_join(pid_push, 0);

更多详细内容 ( 如线程属性设置等细节 ) 参考 下面的博客 :
【C++ 语言】线程 ( 线程创建方法 | 线程标识符 | 线程属性 | 线程属性初始化 | 线程属性销毁 | 分离线程 | 线程调度策略 | 线程优先级 | 线程等待 )
【C++ 语言】Visual Studio 配置 POSIX 线程 ( Windows 不支持 POSIX | 配置文件下载 | 库文件说明 | 配置过程 )



II . 互斥锁

互斥锁使用流程 :


① 声明互斥锁变量 :

//互斥锁变量 
// 1. 先导入头文件
// 2. 定义互斥锁变量
// 3. 在构造函数中进行初始化
// 4. 在析构函数中释放
pthread_mutex_t mutex;

② 初始化互斥锁 :

//初始化互斥锁
pthread_mutex_init(&mutex, 0);

③ 上锁 :

//使用互斥锁将操作锁起来
pthread_mutex_lock(&mutex);

④ 互斥操作 : 需要进行互斥的操作 , 放在 上锁 与 解锁之间进行 ;


⑤ 解锁 :

//解除互斥锁 锁定
pthread_mutex_unlock(&mutex);

⑥ 销毁互斥锁 : 互斥锁使用完毕后进行销毁 ;

//释放互斥锁
pthread_mutex_destroy(&mutex);



III . 条件变量 线程同步

条件变量使用步骤 :


① 声明 条件变量 :

//条件变量
//	使用流程 : 
//	 1. 在构造函数中进行初始化
//	 2. 在析构函数中释放
pthread_cond_t cond;

② 初始化 条件变量 : 一般在构造函数中执行 ;

//初始化条件变量
pthread_cond_init(&cond, 0);

③ 阻塞线程 :

//阻塞等待 , 相当于 Java 中的 wait() 方法
pthread_cond_wait(&cond, &mutex);

④ 解除线程阻塞 : 有两种方式 , 前者每次只能唤醒一个线程 , 并且无法确定唤醒哪个线程 ; 后者唤醒所有由 cond 条件变量阻塞的线程 ;

//方式 1 : 唤醒一个线程 , 唤醒哪个线程 是无法控制的 ; 该方法 相当于 Java 中的 notify() 
pthread_cond_signal(&cond);

//方式 2 : 使用广播通知所有等待的线程 , 唤醒所有的线程 , 相当于 Java 中的 notifyAll
pthread_cond_broadcast(&cond);

⑤ 销毁 条件变量 : 一般在析构函数中进行 ;

//销毁条件变量
pthread_cond_destroy(&cond);


IV . 完整代码示例

006_ThreadSafeQueue.h

// 006_ThreadSafeQueue.h: 标准系统包含文件的包含文件
// 或项目特定的包含文件。

#pragma once

#include <iostream>

// TODO: 在此处引用程序需要的其他标头。

006_ThreadSafeQueue.cpp

// 005_Thread.cpp: 定义应用程序的入口点。
//

#include "006_ThreadSafeQueue.h"
#include <pthread.h>

//引入队列的头文件
#include <queue>

//引入安全队列头文件
#include "SafeQueue.h"

using namespace std;

//线程安全队列
SafeQueue<int> safeQueue;

//向线程安全队列中添加数据
void* pushData(void*) {

	//循环放入数据
	while (true)
	{

		int i;

		//用户从命令行输入数据 , 将该数据 push 到线程安全队列中
		cin >> i;
		safeQueue.push(i);

		cout << "存储数据到线程安全队列 : " << i << endl;

	}


	return 0;
}

//从线程安全队列中取出数据
void* popData(void*) {

	//循环取出数据
	while (true)
	{

		//无限获取数据, 如果线程安全队列中没有数据, 就会在这里阻塞 , 直到 push 进一个数据 , 解除阻塞

		int i = 0;
		//注意传入的是引用 , 可以直接给 i 赋值 , 当做返回值
		safeQueue.popAnyway(i);

		cout << "从线程安全队列中取出出具 : " << i << "\n" << endl;
	}

	return 0;
}


/*
	测试 线程安全队列
*/
int main()
{
	//两个线程 , 一个 push 数据 ( 生产 ) , 一个 pop 数据 ( 消费 )
	pthread_t pid_push, pid_pop;

	//启动一个线程 , 无限循环 向线程安全队列中存储数据
	pthread_create(&pid_push, 0, pushData, 0);

	//启动一个线程 , 无限循环 向线程安全队列中取出数据
	pthread_create(&pid_pop, 0, popData, 0);

	//阻塞 , 等待其中任意一个线程执行完毕 , 实际上是一直在此阻塞 , 如果运行下去 主函数就暂停了
	pthread_join(pid_push, 0);

	system("pause");

	return 0;
}

SafeQueue.h


//避免被多次 include
#pragma once

//避免头文件被多次包含 , 有两种处理方式 
// ① 一种是 #ifndef A #define A #endif 方式
// ② 另一种就是 使用 #pragma once 宏

#include <queue>

//引入头文件 , 需要使用互斥锁相关逻辑
#include <pthread.h>

using namespace std;

//创建一个模板类 , 对 Queue 进行封装 , 
// 保证该 queue 队列是一个线程安全的队列
// 对 queue 队列操作是线程安全的
template <typename T>
class SafeQueue {

public :
	//定义构造函数
	SafeQueue() {

		//初始化互斥锁
		pthread_mutex_init(&mutex, 0);

		//初始化条件变量
		pthread_cond_init(&cond, 0);

	}

	//定义析构函数
	~SafeQueue() {

		//释放互斥锁
		pthread_mutex_destroy(&mutex);

		//销毁条件变量
		pthread_cond_destroy(&cond);

	}

	//向队列中加入元素 , 或 从队列中取出元素
	// queue 队列不是线程安全的 , 现在要保证该 queue 存储元素是线程安全的
	// 需要使用互斥锁控制 push ( 加入元素 ) 和 pop ( 取出元素 ) 操作 ; 

	//向队列中加入元素
	void push(T t) {

		//使用互斥锁将操作锁起来
		pthread_mutex_lock(&mutex);

		//使用互斥锁 , 向队列中加入数据是安全的
		safe_queue.push(t);

		//唤醒一个线程 , 唤醒哪个线程 是无法控制的 ; 该方法 相当于 Java 中的 notify() 
		//pthread_cond_signal(&cond);

		//使用广播通知所有等待的线程 , 唤醒所有的线程 , 相当于 Java 中的 notifyAll
		pthread_cond_broadcast(&cond);

		//解除互斥锁
		pthread_mutex_unlock(&mutex);

	}




	/*
		现在要实现这样一个需求 : 
			如果 pop 方法获取时 , 该队列 q 为空 , 此时肯定获取不到数据了
			但是我们规定每次调用 pop 必须获取一个数据

			这样的话 , 如果检测到 pop 中没有数据 , 就必须先将线程阻塞
			等到有新的元素 push 进来后 , 解除阻塞 , 使用条件变量实现
	
	*/

	//从队列中取出元素 ( 无论如何都要获取到 , 如果获取不到就阻塞到能获取到的时候 )
	void popAnyway(T& t) {

		//使用互斥锁将操作锁起来
		pthread_mutex_lock(&mutex);

		//如果没有数据 , 那么阻塞等待数据 
		if (safe_queue.empty()) {
			//阻塞等待 , 相当于 Java 中的 wait() 方法
			pthread_cond_wait(&cond, &mutex);
		}

		//如果阻塞解除 , 那么执行下面的内容

		//t 参数是传入的引用 , 这里可以直接给 t 引用赋值 
		t = safe_queue.front();

		//将首元素移除
		safe_queue.pop();

		

		//解除互斥锁
		pthread_mutex_unlock(&mutex);

	}


	//从队列中取出元素 ( 取数据时要判空 )
	void pop(T& t) {

		//使用互斥锁将操作锁起来
		pthread_mutex_lock(&mutex);

		//使用互斥锁 , 向队列中加入数据是安全的 , 如果队列是空的 , 就获取不到元素
		if (!safe_queue.empty()) {

			//t 参数是传入的引用 , 这里可以直接给 t 引用赋值 
			t = safe_queue.front();

			//将首元素移除
			safe_queue.pop();
		}

		//解除互斥锁
		pthread_mutex_unlock(&mutex);

	}

private :
	//实际操作的队列 ( 先进先出 ) , 该队列不是线程安全的
	//	如果要保证该 Queue 是线程安全的话 , 就需要为其设置一个互斥锁
	//	下面的 mutex 互斥锁变量 , 就是为了保证该队列是线程安全队列而设置的
	queue<T> safe_queue;

	//互斥锁变量 
	// 1. 先导入头文件
	// 2. 定义互斥锁变量
	// 3. 在构造函数中进行初始化
	// 4. 在析构函数中释放
	pthread_mutex_t mutex;


	//条件变量
	//	使用流程 : 
	//	 1. 在构造函数中进行初始化
	//	 2. 在析构函数中释放
	pthread_cond_t cond;

};

CMakeLists.txt

# CMakeList.txt: 005_Thread 的 CMake 项目，在此处包括源代码并定义
# 项目特定的逻辑。
#
cmake_minimum_required (VERSION 3.8)

#引入头文件
include_directories("include")


#配置自动根据当前是 32 位还是 64 位程序 , 确定静态库的配置目录
if(CMAKE_CL_64)
    set(platform x64)
else()
    set(platform x86)
endif()
#配置静态库 , 用于引导如何链接动态库和静态库
link_directories("lib/${platform}")

#处理 “timespec”:“struct” 类型重定义 报错信息
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DHAVE_STRUCT_TIMESPEC")

# 将源代码添加到此项目的可执行文件。
add_executable (006_ThreadSafeQueue "006_ThreadSafeQueue.cpp" "006_ThreadSafeQueue.h")

#链接生成的 006_ThreadSafeQueue 和线程动态库名字  
#	动态库是 lib/x64 下的 pthreadVC2.lib 
target_link_libraries(006_ThreadSafeQueue  pthreadVC2)

# TODO: 如有需要，请添加测试并安装目标。

运行结果

在这里插入图片描述



V . 示例代码说明

下载完项目后 , 使用 Visual Studio 打开 , 注意需要配置 POSIX 线程库 ;

【Visual Studio】Visual Studio 2019 社区版 CMakeList 开发环境安装 ( 下载 | 安装相关组件 | 创建编译执行项目 | 错误处理 )

【Visual Studio 2019】创建 导入 CMake 项目

【C++ 语言】Visual Studio 配置 POSIX 线程 ( Windows 不支持 POSIX | 配置文件下载 | 库文件说明 | 配置过程 )

韩曙亮
关注
专栏目录
C++多线程--线程安全的队列实现(基于锁)
qls315的博客
04-11 1107
本文参考C++ Concurrency in Action (豆瓣)讲解并给出了完整的基于锁的线程安全的队列。下一篇讲解基于锁的哈希表。
C++多线程并发（三）---线程同步之条件变量
流云
05-03 1万+
一、何为条件变量 在前一篇文章《C++多线程并发编程（二）—线程同步之互斥锁》中解释了线程同步的原理和实现，使用互斥锁解决数据竞争访问问题，算是线程同步的加锁原语，用于排他性的访问共享数据。我们在使用mutex时，一般都会期望加锁不要阻塞，总是能立刻拿到锁，然后尽快访问数据，用完之后尽快解锁，这样才能不影响并发性和性能。 如果需要等待某个条件的成立，我们就该使用条件变量(condition var...
线程安全型队列的实现
01-02
操作系统课程设计线程安全型队列，利用读者优先机制实现互斥。
线程安全和线程不安全理解
热门推荐
ghevinn欢迎您光临
07-14 7万+
线程安全就是多线程访问时，采用了加锁机制，当一个线程访问该类的某个数据时，进行保护，其他线程不能进行访问直到该线程读取完，其他线程才可使用。不会出现数据不一致或者数据污染。 线程不安全就是不提供数据访问保护，有可能出现多个线程先后更改数据造成所得到的数据是脏数据 =========================================================
任务调度与执行的C++线程池
最新发布
Ten_years_star的博客
07-18 826
**线程池结构** - 创建线程池。 - 把函数封装成任务，添加到任务队列。 1. **创建线程池：** 线程池就是创建一定数量的线程（阻塞着获取任务且执行一个任务不会退出（死循环））来抢夺任务队列的任务去执行。 2. **把函数封装成任务，添加到任务队列。** 用`bind`把函数指针和及可变参数封装成`packaged_task`任务，加到任务队列中(这个操作相当于生产者，所以记得加锁)。
C/C++ 线程安全队列
小乌龟的博客
09-09 6602
一、简介线程安全是一个比较严肃的问题，如果处理不好，可能导致数据被破坏，程序崩溃等问题，如何来处理多线程的并发问题？在windows平台有相应的api给你用于控制并发，如互斥锁，信号量，事件，临界区等，定要熟练掌握，当然现在STL库已强大到兼容不同的硬件系统了，当然对于winApi同步可以看这里： 互斥锁，信号量，事件，临界区详情二、分析安全原理基于conditon_variable类实现线程安全
C++ 实现线程安全的任务队列
flyfish
03-06 1万+
C++ 实现线程安全的任务队列 flyfish 2015-3-6 一、三个接口函数说明 1 add 新增任务 2 get_nonblocking 非阻塞获取任务或者空任务 3 get_blocking 阻塞获取任务 头文件 #pragma once #include #include #include #include //任务 网络发送任务使用的结构，通常有...
安全线程队列 — C++
android
01-21 799
一、废话少说，上代码，安全队列 #pragma once #include <queue> #include <memory> #include <mutex> #include <condition_variable> template <typename T> class SafeQueue { private: mutab...
C++线程安全队列_示例代码.zip
01-16
【C++ 语言】线程安全队列 ( 条件变量 | 线程调度 ) : https://hanshuliang.blog.csdn.net/article/details/102851323 下载完项目后 , 使用 Visual Studio 打开 , 注意需要配置 POSIX 线程库 ( 参考以下博客配置...
c++多线程之条件变量
William辰的博客
04-22 2810
1.条件变量condition_variable、wait（）、notify_one（）(通知一个线程) 1.1condition_variable实际上是一个类，是一个和条件相关的一个类，等待一个条件达成，这个类需要和互斥量来配合工作，用的时候我们要生成这个类的对象。 1.2.1wait()函数用于等待一个消息，他的第二个参数lambda表达式返回值是true，那wait（）直接返回，否则w...
基于C++的线程安全容器。.zip
04-30
本项目以C++为基础，旨在实现一套线程安全的容器类，可能包括线程安全的栈、队列、列表或其他容器。这些容器通常会利用C++的互斥量（mutex）、条件变量（condition variable）等同步原语来保证在多线程环境下的正确...
SafeQueue:C++ 中的线程安全队列实现
05-30
安全队列 这个类是一个多生产者、多消费者队列。 它同时提供阻塞和非阻塞消费，而生产总是阻塞。 容量是动态调整的。 实现基于std::queue ，使用std::mutex和std::condition_variable实现线程安全。 可以使用右值引用调用Produce(T&& item)函数。 Consume(T& item)函数立即返回一个布尔值，表示成功。 ConsumeSync(T& item)方法将阻塞调用线程，直到它可以从队列中取出一个项目。 Finish方法停止所有等待的消费者 (ConsumeSync)，并使它们返回 false。 例子 制作人： SafeQueue<MyType> queue; // insert elements queue.Produce(std::move(var1)); queue.Produce(std::move(var2)); 非阻塞消费
C++实现线程安全队列
05-14
使用互斥变量技术完成C++安全队列，同时编写测试代码进行此队列的测试。
C++ 线程安全的队列
Cdreamfly的博客
03-08 9305
无界队列 #include<queue> #include<mutex> #include<condition_variable> #include<optional> #include<cassert> #include<thread> template<typename T,typename Container = std::queue<T>> class Queue //无界队列 { public: .
基于std::queue C++11 线程安全队列。
fengchu3415的博客
09-06 1万+
网上看到的封装不错，记录一下，非原创。 #pragma once #include &lt;atomic&gt; #include &lt;condition_variable&gt; #include &lt;functional&gt; #include &lt;memory&gt; #include &lt;mutex&gt; #include &lt;queue&gt; templa...
C++线程安全队列
让代码改变世界
05-25 1450
和锁类似，条件变量用于控制两个线程的执行顺序，主要包括wait()和notify()两类接口（有各种形式，这里用的wait和notify_one是其中一组），wait是等待某一条件满足，如果满足则继续执行，否则会进入一个waitting队列，而notify是从队列中唤醒一个线程，去执行。但这么写可能导致其类型与类的模板类型不一致，所以要对其做一个类型校验，这也是模板编程中常见到的，由于模板是一种强制类型匹配，没有了继承体系的限制，所以要程序员自己去判断。1. 利用模板类来实现，以适配不同的元素类型。
C++并发编程:构建线程安全队列(第二部分：细粒度锁)
qq_42896106的博客
09-05 497
使用多把锁和条件变量可以减少锁冲突,提供多个并发访问接口智能指针帮助简化内存管理通过标准库构建的线程安全队列,可以直接应用于多线程程序中上面这个线程安全队列利用C++11特性设计了一个实用的多线程数据结构,既保证了线程安全,也提供了良好的并发性能。关键技术点包括互斥量、条件变量、智能指针的使用,这些都是效实用的C++并发编程技能。
c语言rand线程安全,c++11 多线程编程——如何实现线程安全队列
weixin_39605706的博客
05-20 359
线程安全队列的接口文件如下：#include templateclass threadsafe_queue {public:threadsafe_queue();threadsafe_queue(const threadsafe_queue&);threadsafe_queue& operator=(const threadsafe_queue&) = delete;voi...
C++多线程共享队列
05-25
在 C++ 中实现多线程共享队列可以使用标准库中的 std::queue 和 std::mutex 来实现。具体实现步骤如下： 1. 定义一个模板类，用于表示队列中的元素类型； 2. 在队列类中定义两个 std::queue 成员变量，一个用于存储任务，另一个用于存储等待的线程； 3. 定义一个 std::mutex 对象，用于保护队列的数据； 4. 在队列类中定义 push() 和 pop() 函数，这两个函数需要使用 std::lock_guard<std::mutex> 对象来保护队列的数据； 5. 在 push() 函数中向任务队列中添加任务，并通知等待的线程有新任务加入； 6. 在 pop() 函数中从任务队列中取出一个任务并返回，如果队列为空则等待新任务的到来。 下面是一个简单的多线程共享队列的实现： ```c++ #include <queue> #include <mutex> #include <condition_variable> template<typename T> class ThreadSafeQueue { public: ThreadSafeQueue() = default; void push(const T& value) { std::lock_guard<std::mutex> lock(m_mutex); m_queue.push(value); m_condition.notify_one(); } bool pop(T& value) { std::unique_lock<std::mutex> lock(m_mutex); m_condition.wait(lock, [this]{ return !m_queue.empty(); }); if (m_queue.empty()) { return false; } value = m_queue.front(); m_queue.pop(); return true; } private: std::queue<T> m_queue; mutable std::mutex m_mutex; std::condition_variable m_condition; }; ``` 在上面的代码中，我们使用 std::unique_lock<std::mutex> 来保护队列的数据，并使用 std::condition_variable 来通知等待的线程有新任务加入。在 push() 函数中，我们先获取 std::lock_guard<std::mutex> 对象来保护队列的数据，然后向任务队列中添加任务，并通过 m_condition.notify_one() 通知等待的线程有新任务加入。在 pop() 函数中，我们获取 std::unique_lock<std::mutex> 对象来保护队列的数据，并通过 m_condition.wait() 等待新任务的到来。如果队列中有任务，则取出一个任务并返回，否则返回 false。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值