自定义线程

最新推荐文章于 2025-01-21 20:08:30 发布

逆流code

最新推荐文章于 2025-01-21 20:08:30 发布

阅读量102

点赞数

分类专栏： C++ 文章标签： c++

本文链接：https://blog.csdn.net/weixin_44949092/article/details/132053248

版权

C++ 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

本文介绍了如何使用C++实现一个名为BaseThread的类，它提供线程的启动、暂停、终止功能，并确保任务安全执行。通过互斥量和条件变量管理线程状态和任务队列。

摘要由CSDN通过智能技术生成

解决如下问题：

可不断加入预执行函数
安全的暂停和终止线程操作

BaseThread.h

#pragma once
#include <thread>
#include <iostream>
#include <mutex>
#include <condition_variable>
#include <functional>
#include <queue>

using namespace std;

class BaseThread
{
public:
	enum RunningState
	{
		START = 0,
		PAUSE,
		STOP
	};
	
	BaseThread();
	~BaseThread() = default;
	
	// 开启线程
	void ThreadStart();
	// 暂停线程
	void ThreadPause();
	// 终止线程
	void ThreadStop();
	// 得到线程状态
	RunningState GetRunningState();
	// 添加任务
	bool AddTask(function<bool()> func);

protected:
	void Run();
	// 执行任务，主要是任务队列中取任务和执行任务的操作
	void TaskAction();
	// 挂起等待
	void WaitIfPaused();


private:
	RunningState m_state;			// 线程状态
	unique_ptr<thread> m_thread;	// 包裹智能指针的线程
	queue<function<bool()>> taskQueue;	// 任务队列
	mutex mtx;						// 互斥量
	condition_variable cond;		// 主动暂停条件变量
	condition_variable cond_queueEmpty;	// 队列空条件变量
};

BaseThread.cpp

#include "BaseThread.h"


BaseThread::BaseThread() {
	m_thread = unique_ptr<thread>(new thread(&BaseThread::Run, this));
	m_thread->detach();
}

void BaseThread::ThreadStart(){
	unique_lock<mutex> lock(mtx);
	m_state = RunningState::START;
	cond.notify_one();
}

void BaseThread::ThreadPause() {
	unique_lock<mutex> lock(mtx);
	m_state = RunningState::PAUSE;
}

void BaseThread::ThreadStop() {
	unique_lock<mutex> lock(mtx);
	m_state = RunningState::STOP;
	cond.notify_one();
}

BaseThread::RunningState BaseThread::GetRunningState() {
	return m_state;
}

void BaseThread::Run() {
	m_state = RunningState::START;
	cout << "thread ID:" << this_thread::get_id << " is start!\n";
	// 之所以这种方法终止线程安全，是因为该执行的模块都一起执行完了才退出循环。
	while (GetRunningState() != RunningState::STOP) {
		WaitIfPaused();
		if (GetRunningState() == RunningState::START) TaskAction();
	}
	cout << "Thread ID : " << this_thread::get_id << " is stop.\n";
}

void BaseThread::TaskAction() {
	unique_lock<mutex> lock(mtx);
	m_state = RunningState::PAUSE;
	cond_queueEmpty.wait(lock, [this] {return !taskQueue.empty(); });
	m_state = RunningState::START;
	taskQueue.front()();
	taskQueue.pop();
}

void BaseThread::WaitIfPaused() {
	unique_lock<mutex> lock(mtx);
	cond.wait(lock, [this] {return GetRunningState() != RunningState::PAUSE; });
}



bool BaseThread::AddTask(function<bool()> func) {
	if (func == NULL) return false;
	unique_lock<mutex> lock(mtx);
	taskQueue.push(func);
	cond_queueEmpty.notify_one();
	return true;
}