C++多线程学习

最新推荐文章于 2024-08-25 06:11:42 发布
最新推荐文章于 2024-08-25 06:11:42 发布
阅读量391 收藏 8
点赞数 4
文章标签： c++ 学习 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50816320/article/details/137522343
版权
本文详细介绍了C++中线程的基本概念、创建、同步机制（如join,detach,mutex,atomic等）、线程函数参数传递、线程池、异步编程（async,packaged_task,promise）以及单例模式在多线程中的应用。
摘要由CSDN通过智能技术生成

1.主程序等待线程执行完毕
我们先来写一个最最最基本的线程代码

#include <iostream>
#include <thread>
using namespace std;

void print()
{
	cout << "Hello World" << endl;
}

int main()
{
	//1.创建线程
	std::thread thread1(print);
	return 0;
}

当我们打断点的时候可以发现，当执行到std::thread thread1(print)时main函数并不会直接跳到print函数里等待其执行完成之后再retun 0，而是直接return，所以这里会报错。
所以这时候我们需要join函数

	std::thread thread1(print);
	thread1.join();

这时候就不会报错了，但是这里使用join会导致主线程一直等待子线程，这时候可以使用detach()

std::thread thread1(print);
	thread1.detach();

这里detach调用之后程序不会执行任何东西，因为主函数已经结束了，但是print也实实在在被调用了
在这里插入图片描述
优化：


int main()
{
	//1.创建线程
	std::thread thread1(print);
	if (thread1.joinable())
	{
		thread1.join();
	}
	return 0;
}

我们接着来写下一段代码

#include <iostream>
#include <thread>
using namespace std;

void f(int & x)
{
	x += 1;
}

int main()
{
	int a = 1;
	std::thread thread1(f, &a);
	thread1.join();
	return 0;
}

这里会编译失败，原因是thread 构造函数的参数需要是可调用的对象，并且线程函数的参数会被拷贝或移动传递给线程函数。然而，整数 a 的地址并不是可调用的对象，因此无法直接将其作为参数传递给线程函数。所以需要将&a修改成ref(a)

std::thread thread1(f, ref(a));

同理，我们写成指针形式

#include <iostream>
#include <thread>
using namespace std;

void f(int * x)
{
	*x += 1;
}

int main()
{
	int* a = new int(1);
	std::thread thread1(f, a);
	thread1.join();
	return 0;
}

这样不会报错，但在调用的下面使用delete便会马上报错

int main()
{
	int* a = new int(1);
	std::thread thread1(f, a);
	delete(a);
	thread1.join();
	return 0;
}

在这里插入图片描述
接下来是类版本的

#include <iostream>
#include <thread>
#include<memory>
using namespace std;

class A {
public:
	void f() {
		std::cout << "Hello" << endl;
	}
};

int main()
{
	shared_ptr<A> a = make_shared<A>();
	std::thread t(&A::f, a);
	t.join();
}

这里使用智能指针a来管理内存

接下来我们研究竞争的问题

#include <iostream>
#include <thread>
using namespace std;

int a = 0;

void f()
{
	for (int i = 0; i < 10000; i++)
		a += 1;
}

int main()
{
	std::thread t1(f);
	std::thread t2(f);
	t1.join();
	t2.join();

	std::cout << a << endl;
	return 0;
}

这里预期应该是20000，但是却是一个小于两万的数，所以这里用一个互斥锁

#include <iostream>
#include <thread>
#include<mutex>
using namespace std;

int a = 0;
std::mutex mtx;
void f()
{
	for (int i = 0; i < 10000; i++)
	{
		mtx.lock();
		a += 1;
		mtx.unlock();
	}		
}

int main()
{
	std::thread t1(f);
	std::thread t2(f);
	t1.join();
	t2.join();
	std::cout << a << endl;
	return 0;
}

然后我们学习lock_guard
这个lock_guard有点像智能指针，自己会释放锁

for (int i = 0; i <10000; i++)
	{
		lock_guard<mutex>lg(mtx);
		a += 1;
	}

接着是unique_guard
unique_guard比lock_guard方法多一些，所以消耗的资源要多一些
主要多加了延迟加锁的操作，这里简单对这个进行操作

#include <iostream>
#include <thread>
#include<mutex>
using namespace std;

int a = 0;
std::timed_mutex mtx;
void f()
{
	for (int i = 0; i <2; i++)
	{
		unique_lock<timed_mutex>lg(mtx,defer_lock);
		if (lg.try_lock_for(chrono::seconds(2)))
		{
			std::this_thread::sleep_for(std::chrono::seconds(1));
			a++;
		}
	}		
}

int main()
{
	std::thread t1(f);
	std::thread t2(f);
	t1.join();
	t2.join();
	std::cout << a << endl;
	return 0;
}

然后我们学习一下线程中的单例，首先介绍一下懒汉模式，提前把静态变量声明好，需要直接拿就行

#include <iostream>
#include <thread>
#include<mutex>
#include<string>
using namespace std;

class Log
{
public:
	Log() {};
	Log(const Log& log) = delete;
	Log& operator=(const Log& log) = delete;

	static Log& GetInstance() 
	{
		static Log log;
		return log;
	}
	void PrintLog(std::string msg)
	{
		std::cout << msg << endl;
	}
private:
	std::once_flag once;
};

int main()
{
	
}

然后是饿汉模式，只有需要的时候才调用

#include <iostream>
#include <mutex>
#include <string>

static Log* log = nullptr;
class Log
{
public:
    static Log& GetInstance()
    {
        if (!log)
            return *log;
    }

    void PrintLog(std::string msg)
    {
        std::cout << msg << std::endl;
    }

    Log() {}
    Log(const Log& log) = delete;
    Log& operator=(const Log& log) = delete;

private:
    std::once_flag once;
};

int main()
{
    Log& log = Log::GetInstance();
    log.PrintLog("Hello, World!");

    return 0;
}

这里可以用call_once来确保函数只会被执行一份

之后是生产者-消费者模型
这里使用q_cv.notify_one()来通知消费者线程，所以最后的执行结果就是生产者填一个进去，然后消费者再拿一个出来

#include <iostream>
#include <mutex>
#include <string>
#include<condition_variable>
#include<queue>

std::queue<int>q;
std::condition_variable q_cv;
std::mutex mtx;

void Producer() {
	for (int i = 0; i < 10; i++) 
	{
		std::unique_lock<std::mutex>lock(mtx);
		q.push(i);
		q_cv.notify_one();
		//通知消费者取任务
		std::cout << "task " << i << std::endl;
	}
	std::this_thread::sleep_for(std::chrono::microseconds(100));
		
}
void Consumer() 
{
	while (1)
	{
		std::unique_lock<std::mutex>lock(mtx);
		bool isempty = q.empty();
		q_cv.wait(lock, []() { return !q.empty(); });
		int value = q.front();
		q.pop();
		std::cout << "Consumer" << value << std::endl;
	}
}

int main()
{
	std::thread t1(Producer);
	std::thread t2(Consumer);
	t1.join();
	t2.join();
	return 0;
}

#include <iostream>
#include <thread>
#include <mutex>
#include <string>
#include <condition_variable>
#include <queue>
#include <vector>
#include <functional>
#include <chrono> // 添加这个头文件来使用 sleep_for

using namespace std;

class ThreadPool {
public:
    ThreadPool(int numThreads) : stop(false) {//使用成员初始化列表把stop设置为false
        for (int i = 0; i < numThreads; ++i) { //针对线程数
            threads.emplace_back([this] {     //[this] 表示捕获当前对象的指针，使得 lambda 表达式可以访问当前对象的成员变量和成员函数。
                while (true) {
                    unique_lock<mutex> lock(mtx);
                    condition.wait(lock, [this] { //当线程池不为空时占用
                        return !tasks.empty() || stop;
                        });
                    if (stop && tasks.empty())
                        return;

                    function<void()> task(move(tasks.front()));//使用 std::move() 可以将资源的所有权转移，避免额外的拷贝操作。
                    tasks.pop();
                    lock.unlock();
                    task();
                }
                });
        }
    }

    ~ThreadPool() {
        {
            std::unique_lock<mutex> lock(mtx);
            stop = true;
        }
        condition.notify_all();
        for (auto& t : threads) {
            t.join();
        }
    }

    template<class F, class... Args>
    void enqueue(F&& f, Args&&... args) //用于向线程池中添加任务，F 是任务函数的类型，而 Args... 是任务函数的参数类型。
    {
        function<void()> task = bind(forward<F>(f), args...);
        {
            unique_lock<mutex> lock(mtx);
            tasks.emplace(move(task));
        }
        condition.notify_one();
    }

private:
    vector<thread> threads;
    queue<function<void()>> tasks;//存储任务函数
    condition_variable condition;
    mutex mtx;
    bool stop;
};

int main() {
    ThreadPool pool(4);
    for (int i = 0; i < 10; i++) {
        pool.enqueue([i] {
            cout << "Task " << i << " is running" << endl;
            this_thread::sleep_for(std::chrono::seconds(1));
            cout << "Task " << i << " is done" << endl;
            });
    }
    this_thread::sleep_for(std::chrono::seconds(5)); // 等待所有任务完成
    return 0;
}

接下来讲异步并发
async的运行

#include <iostream>
#include <future>

using namespace std;

int func()
{
	int i = 0;
	for ( i = 0; i < 1000; i++) {
		i++;
	}
	return i;
}
int main()
{
	future<int> future_result = async(launch::async, func);//调用的时候func已经开始运行了，结果存在future_result
	cout << func() << endl;
	cout << future_result.get() << endl;//如果没有运行完，get会等待
	return 0;
}

然后是packaged_task

#include <iostream>
#include <future>

using namespace std;

int func()
{
	int i = 0;
	for ( i = 0; i < 1000; i++) {
		i++;
	}
	return i;
}
int main()
{
	packaged_task<int()>task(func);
	auto future_result = task.get_future();//此时只是把fun包裹，并没有运行
	thread t1(move(task));//这里必须用move 
	cout << func()<<endl;
	t1.join();
	cout << future_result.get() << endl;
	return 0;
}

promise是一个类模板，用于在一个线程产生一个值，并在另一个线程获取这个值

#include <iostream>
#include <future>

using namespace std;

void func(promise<int>&f) {
	f.set_value(1000);
}

int main()
{
	promise<int>f;
	auto future_result = f.get_future();//这个 future 对象可以用来获取 promise 对象设置的值。
	thread t1(func, ref(f));
	t1.join();
	cout << future_result.get() << endl;
	return 0;
}

最后一个atomic
用atomic解决之前互斥的问题
atomic是C++11标准库的一个模板类，用于实现多线程下的原子操作。它提供了一种线程安全的方式来访问和修改共享变量，可以避免多线程环境中的数据竞争问题。

#include <iostream>
#include <thread>
#include<mutex>
#include<atomic>
using namespace std;

int a = 0;
std::mutex mtx;

std::atomic<int>shared_data = 0;
void f()
{
	for (int i = 0; i < 10000; i++)
	{
		shared_data++;
	}
}

int main()
{
	std::thread t1(f);
	std::thread t2(f);
	t1.join();
	t2.join();
	std::cout << a << endl;
	return 0;
}
蓝调请不再忧郁
关注
  • 4
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++多线程学习笔记（一）
m0_63932570的博客
05-04 2115
今天是五月三号，五一放假五天，博主也就给自己放了三天假，去游山玩水，吃美食。今天是第四天了，也该慢慢找回学习的状态啦。所以今天博主也是改变自己最近懒惰的状态，来开始自己学习多线程的基础知识。多线程这部分内容对于java，c++爱好者应该不陌生，经常听到或看到的吧。建议在学完c++基础语言知识后的同学们，还是值得学一下这部分内容的（其实也不算很多内容）。下面我们正式开始来看看吧 1.理解多线程。 多线程并发指的是在同一个进程中执行多个线程。C++11提供了语言层面上的多线程，包含在头文件<threa
C++ 多线程学习笔记（2）：线程启动、结束、创建线程方法
热门推荐
佚失的诗篇
05-07 2万+
文章目录一、线程启动、结束、创建线程方法1. 创建线程的一般方法（1）thread() 一、线程启动、结束、创建线程方法 1. 创建线程的一般方法 主线程在从main开始执行，一旦主线程从main()返回，则整个程序（进程）结束 此时如果其他子线程还没执行完，一般会被操作系统强行终止 通常我们创建的子线程从一个函数开始运行，一旦此函数运行完毕，代表这个线程运行结束 如果想保持子线程一直运...
C++ 多线程学习：目录
Rain_ZZX的博客
01-12 403
C++多线程学习（一):认识线程，创建线程-CSDN博客C++多线程学习[二]:线程的传参以及传参的一些坑-CSDN博客
C++多线程
钟离默的个人博客
08-13 8439
一、多线程简介 C++11 新标准中引入了四个头文件来支持多线程编程，他们分别是<atomic> ，<thread>，<mutex>，<condition_variable>和<future>。 <atomic> ：该头文主要声明了两个类, std::atomic 和 std::atomic_flag，另外还声明了一套 C 风格的原子类型和与 C 兼容的原子操作的函数。 <thread>：该头文件主要声明了 std::th
C++ 多线程编程
qq_44891434的博客
08-29 1561
C++ 多线程编程
C++ 多线程学习04 多线程状态与互斥锁
qq_42567607的博客
06-26 1325
初始化→就绪态：操作系统为线程分配好了资源，将其挂载CPU的就绪队列上。 就绪→运行：该线程排在就绪队列队首元素，且CPU调度到了该线程(如时间片轮转算法、高响应比优先算法、短作业优先等)，将其交给CPU去运行 运行→就绪：正在CPU上运行的线程用于CPU的调度中断了运行，挂载就绪队列队尾 就绪→阻塞：X 运行→阻塞：当进程请求某一资源（如外设）的使用和分配或等待某一事件的发生（如IO操作的完成）时，它就从运行状态转换为阻塞状态。进程以系统调用的形式请求操作系统提供服务，这是一种特殊的、由运行用户态程序调用
C++ 多线程学习(3) ---- 条件变量
小猪佩奇的博客
06-30 6616
比如上面的代码中如果不加锁保护，在判断 mDisplayQueue.empty() 的条件成立后，此时线程被挂起，调度了另一个线程，另外的线程用于唤醒这个 condition_variable，此时当前线程因为还没有处于 wait 状态上（没有处于调度器的等待队列上），所以会丢失掉这个唤醒操作，如果这个唤醒操作只有一次，那么当前线程很可能永远处于阻塞等待的状态上。要解决该问题，就必须让生产者在缓冲区满时休眠，等到下次消费者消耗缓冲区中的数据的时候，生产者才能被唤醒，开始往缓冲区添加数据。
C++多线程传参详解
mingwu96的博客
02-20 7313
目录 1.线程传参的过程 1.1 内置类型的实参 1.1.1参数按值传递 1.1.2如果想按引用传递，则需要调用std::ref 1.2 类类型的实参 1.2.1 传递的是左值对象 1.2.2 传递的是临时对象（即右值对象） 1.2.3 传递的参数需要隐式类型转换 1.2.4 传递的参数是指针 1.3 传入智能指针unique_ptr 1.线程传参的过程 下面是thread的源代码 template< class Function, class... Args &g
c++多线程学习笔记（二）之线程入口并封装线程基类接口
m0_63932570的博客
05-03 795
今天我们来扩展c++多线程学习中的关于线程入口并封装线程基类接口的内容，这部分内容也是相对来说比较重要的，涉及到类与成员函数，还有几个比较常见又陌生的概念。下面让我们一起来看看吧。 首先下面是基本接口的调用： 下面是样例代码： #include<iostream> #include<thread> #include<string> using namespace std; class MyThread { public: //入口线程函数 v...
C++ 多线程日志记录
09-07
总的来说，实现C++多线程日志记录需要理解多线程编程、同步机制以及日志管理的原理。通过分析提供的源代码文件，我们可以学习到如何将这些理论知识应用到实际的开发中，从而提高程序的并发性能和日志处理能力。
yolov5目标检测多线程C++部署
08-12
** yolov5目标检测多线程C++...总的来说，YOLOv5的C++多线程部署是一项综合了计算机视觉、深度学习、多线程编程和性能优化的复杂任务。理解这些知识点并灵活运用，能够帮助开发者构建出高效、可扩展的目标检测系统。
C++ 并发多线程日志处理
02-28
在C++编程中，多线程日志处理是一项重要的任务，尤其在高并发环境中，能够有效地记录、管理和分析系统运行时的信息。C++11引入了标准库中的`<thread>`，使得多线程编程变得更加方便，同时也为日志处理带来了新的挑战...
C++多线程网络聊天程序 .zip
07-12
通过解压并分析源代码，我们可以深入理解多线程在网络聊天程序中的具体应用和实现细节，这对于学习C++多线程编程和网络编程来说是一个很好的实践案例。同时，这也为我们提供了改进和优化聊天程序的机会，例如，使用...
C语言：文件（写入，读取）
2301_80311224的博客
08-21 714
区分二者很简单，我们可以选定一个文件，以记事本打开，如果其中的内容你能看懂，他就是一个文本文件，相反，如果是一堆你看不懂的东西，那他就是二进制文件。w+：既能读又能写，若文件不存在则创建，若文件存在则清空。若成功打开会返回文件指针，若失败则返回NULL。w：写入，若文件不存在则创建，若文件存在则清空。r：只读取，若文件不存在，fopen调用失败。a+：既能读又能写，若文件不存在则创建。在打开和关闭文件中，进行操作文件。a：追加写入，若文件不存在则创建。r+：既能读又能写，文件必须存在。
【C++】链表
qq_38801607的博客
08-22 559
链表是一种常见的动态数据结构，与数组相比，它在插入和删除操作中具有更高的效率。链表的每个元素称为节点（Node），节点包含两个部分：数据域（存储数据）和指针域（指向下一个节点的指针）。链表的最大特点是节点的内存位置不需要连续，可以通过指针来链接在一起。
C++ 重载运算符和重载函数
最新发布
lly202406的博客
08-25 380
在C++编程语言中，运算符重载和函数重载是两个非常核心的概念，它们允许开发者扩展或重新定义运算符和函数的行为，以适应特定的数据类型或对象。本文将详细探讨C++中的运算符重载和函数重载，包括它们的基本概念、使用场景、实现方式以及注意事项。
QT Quick QML 实例之定制 TableView
火山上的企鹅
08-24 666
视图（如ListView）中请求模型的数据时，视图会调用 data() 函数，并传递相应的 QModelIndex 和 role， data() 函数会根据这些参数返回对应的数据。编辑数据: 当用户在视图中编辑数据（如在表格单元格中输入文本或选择复选框）时，视图会调用 setData() 函数，模型根据提供的新数据更新相应的项。：setData() 用于更新数据，而 data() 则用于获取数据。headerData() 通常与 data() 一起使用，前者用于表头的显示，后者用于表格中具体单元格的显示。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值