C++11线程池、多线程编程（附源码）

2024-09-07 23:44
文章标签 c++ 源码 线程 多线程 编程

本文主要是介绍C++11线程池、多线程编程（附源码），希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

Test1

示例源码展示：

#include<iostream>
#include<thread>
#include<string>
using namespace std;void printHelloWord(string s)
{cout << s << endl;//return;
}
int main()
{string s;s = "wegfer";thread thread1(printHelloWord,s);//thread1.join();//在线程没有结束的情况下保持主线程一直工作着，不会往下运行导致主线程结束了，线程还没结束。//thread1.detach();//分离子线程和主线程，主线程结束了子线程还在后台运行，也就是成为孤儿进程bool isJoinable = thread1.joinable();//返回一个布尔值，表明这个线程是不是可以调用join或者detach功能，一旦线程用过join或者detach功能，返回值就是0cout << isJoinable << endl;//输出结果1if (isJoinable){thread1.join();}bool isJonable_2 = thread1.joinable();cout << isJonable_2 << endl;//输出结果0system("pause");return 0;
}

函数：

  1. .join（）：阻塞线程，当线程没有运行结束的时候主线程一直停着不关闭，防止子线程还没运行完，主线程结束了报错
  2. .detach（）：分离子线程和主线程，主线程结束了子线程还在后台运行，也就是成为孤儿进程
  3. joinable（）：返回一个布尔值，表明这个线程是不是可以调用join或者detach功能，一旦线程用过join或者detach功能，返回值就是0

Text 02 线程函数中的数据未定义错误

1.传递临时变量问题

void foo(int & x)
{x = x + 1;
}
void test02()
{int a = 1;/*thread t(foo, a);t.join();cout << a << endl;//运行报错，因为t(foo, a)默认情况下传的是值，不是引用，改成ref(a)就可以*/thread t(foo, ref(a));t.join();cout << a << endl;//输出结果2
}

2.传递指针或引用指向局部变量的问题

#include<iostream>
#include<thread>
#include<string>
using namespace std;int a = 1;
thread t;
void fool(int &x)
{x = x + 1;
}void test()
{//int a = 1;//会报错,但也不一定，不同环境下有可能也不会，但是这是不安全的情况，所以最好还是放外面t = thread(fool, ref(a));//a在栈里面，如果test先于foo执行完毕，那么a就释放掉了，线程就报错了。把a放到外面就好了
}int main()
{test();t.join();system("pause");return 0;
}

3.传递指针或引用已释放的内存的问题

void fool(int *x)
{*x = *x + 1;}
int main()
{int *ptr = new int(1);thread t(fool, ptr);//这种代码崩溃不崩溃看运气，而且还会出现可能不崩溃，但是已经不按照预想的情况运行了，所以不要这么写delete ptr;//这里已经释放了，万一线程还没运行完，他在去这里找，已经不确保正确性了t.join();system("pause");return 0;
}

4.类成员函数作为入口函数，类对象被提前释放
类似于上面的3
解决办法：智能指针

#include<iostream>
#include<thread>
#include<string>
using namespace std;class A {
public:void foo(){cout << "Hello" << endl;}
};
int main()
{shared_ptr<A> a = make_shared<A>();thread t(&A::foo, a);//当使用 std::thread 来执行成员函数时，调用类的成员函数与调用普通的函数不一样。成员函数需要一个对象实例来调用，因为它是绑定到特定对象的，因此在调用时必须传递一个指向该对象的指针或引用，所以这里A：：foo用引用t.join();system("pause");
}

5.入口为类的私有成员函数
一下报错，无法运行


class A {
private:void foo(){cout << "Hello" << endl;}
};
int main()
{shared_ptr<A> a = make_shared<A>();thread t(&A::foo, a);//当使用 std::thread 来执行成员函数时，调用类的成员函数与调用普通的函数不一样。成员函数需要一个对象实例来调用，因为它是绑定到特定对象的，因此在调用时必须传递一个指向该对象的指针或引用t.join();system("pause");
}

解决办法：友元，或者通过调用类内的公有函数在调用私有函数

class A {private:friend void thread_foo();void foo(){cout << "Hello" << endl;}
};
void thread_foo()
{shared_ptr<A> a = make_shared<A>();thread t(&A::foo, a);//当使用 std::thread 来执行成员函数时，调用类的成员函数与调用普通的函数不一样。成员函数需要一个对象实例来调用，因为它是绑定到特定对象的，因此在调用时必须传递一个指向该对象的指针或引用t.join();
}
int main()
{thread_foo();system("pause");
}

test03 互斥量解决多线程数据共享问题

下面这样的代码又安全隐患，有可能是我们想要的20000，也有可能不是。

int a = 0;
void func()
{for (int i = 0; i < 10000; i++){a = a + 1;}
}
int main()
{thread t1(func);thread t2(func);t1.join();t2.join();cout << a << endl;system("pause");return 0;
}

解决办法：加锁，互斥锁

int a = 0;
mutex mtx;
void func()
{for (int i = 0; i < 10000; i++){mtx.lock();//加锁a = a + 1;mtx.unlock();//解锁}
}
int main()
{thread t1(func);thread t2(func);t1.join();t2.join();cout << a << endl;system("pause");return 0;
}

test5 lock_guard与unique_lock

lock_guard： C++标准库中的一种互斥量封装类，用于保护共享数据，防止多个线程同时访问同一资源而导致数据竞争问题。
特点：构造函数被调用时，该互斥量会被自动锁定
析构函数被调用时，该互斥量会被自动解锁
lock_guard对象不能复制或移动，因此它只能在 局部作用域中使用

void func()
{for (int i = 0; i < 10000; i++){lock_guard<mutex> lg(mtx);//lock_guard标准库中的类，可以管理锁的自动释放。它会在构造函数中自动尝试锁定 mtx，并在该作用域结束时，自动调用析构函数来释放 mtx 锁。这一轮训话结束就自动解锁了a = a + 1;}
}
int main()
{thread t1(func);thread t2(func);t1.join();t2.join();cout << a << endl;system("pause");return 0;
}

unique_lock： C++标准库中的一个互斥封装类，用于在多线程程序中对互斥量进行加锁和解锁操作。它的主要特点是可以对互斥量进行更灵活的管理，包括延迟加锁、条件变量、超时等。
unique_lock:提供的成员函数：
lock（）：尝试对互斥量进行加锁操作，如果当前互斥量已经被其他线程持有，则当前线程被阻塞，直到互斥量被成功加锁。
try_lock():尝试对互斥量进行加锁，如果当前互斥量已经被其他线程持有，则函数立刻返回false，否则返回true。
try_lock_for():尝试对互斥量进行加锁，如果当前互斥量已经被其他线程持有，则当前线程会被阻塞，直到互斥量被成功加锁，或者超过了指定的时间。
tyr_lock_until():尝试对互斥量进行加锁操作，如果互斥量已经被其他线程持有，则当前线程会被阻塞，直到互斥量被成功加速，或者超过了指定的时间。
unlock（）：对互斥量进行解锁操作。

void func()
{for (int i = 0; i < 10000; i++){unique_lock<mutex> lg(mtx);//也会成功加锁a = a + 1;}
}

void func()
{for (int i = 0; i < 10000; i++){unique_lock<mutex> lg(mtx,defer_lock);//成功构造但是不加锁a = a + 1;}
}

输出结果：
在这里插入图片描述
try_lock_for()：

int a = 0;
timed_mutex mtx;
void func()
{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(chrono::seconds(3));a = a + 1;}//延迟加锁，5秒内没加上就不加了}
}
int main()
{thread t1(func);thread t2(func);t1.join();t2.join();cout << a << endl;system("pause");return 0;
}

锁只是不允许获取资源，不是让你加不上锁就直接返回结束你的线程，而是加不上锁的话那就返回false，然后继续后续操作。

int a = 0;
timed_mutex mtx;
void func()
{for (int i = 0; i < 2; i++){unique_lock<timed_mutex> lg(mtx, defer_lock);//成功构造但是不加锁lg.try_lock_for(chrono::seconds(2));//延迟加锁，5秒内没加上就不加了std::this_thread::sleep_for(chrono::seconds(3));a = a + 1;}
}
int main()
{thread t1(func);thread t2(func);t1.join();t2.join();cout << a << endl;//输出结果为4system("pause");return 0;}

Test06 call_once与其使用场景

单例设计模式是一种常见的设计模式，用于确保某个类只能创建一个实例。由于单例实例是全局唯一的，因此在多线程环境中使用单例模式时，需要考虑线程安全问题。
最常见的是日志类，全局只有一个日志类，日志类可以打印各种信息。
只可以在线程函数中使用call_once
生产者-消费者问题的实现：

#include<iostream>
#include<thread>
#include<string>
#include<mutex>
#include<condition_variable>
#include<queue>
#include<vector>
#include<functional>using namespace std;
queue<int> g_queue;
condition_variable g_cv;
mutex mtx;
void Producer()
{for (int i = 0; i < 10; i++){unique_lock<mutex>lock(mtx);g_queue.push(i);//队列为空之后加任务g_cv.notify_one();cout << "task:"<<i << endl;}
}
void Consumer()
{while (1){unique_lock<mutex>lock(mtx);bool isempty = g_queue.empty();//g_cv.wait(lock, !isempty);//队列不空的时候消费者继续取g_cv.wait(lock, [](){return !g_queue.empty();});int value = g_queue.front();g_queue.pop();cout << "value: " << value << endl;}
}int main()
{thread t1(Producer);thread t2(Consumer);t1.join();t2.join();system("pause");return 0;
}

运行结果：
在这里插入图片描述
**注：**也有可能是生产者生产完了商品消费者才开始消费，这是因为生产者和消费者是独立的两个线程，他们的运行顺序并不总是由我们决定的，操作系统可能会调度他们，有可能是操作系统衡量之后觉得应该让生产者先生产。
出现原因：1.线程调度不确定性：线程的执行顺序有操作系统调度，那次运行可能操作系统觉得应该 让生产者进行生产。
2.生产者的生产速度大于消费者消费速度，可以在生产者那里加一个sleep_for，增加生产者的生产时间（生产者只需要push，而消费者还需要wait）

Test07 生产者与消费者问题

生产者和消费者二者一个创建任务一个取走任务，他们一个操纵任务队列的头部一个操纵任务队列的尾部，任务队列需要互斥访问，1. 因为生产者、消费者对任务队列执行取出或添加的操作后需要更改队列的指针或进行一些内部结构的更新，如果不互斥有可能会使得队列崩溃。2. 防止“写-读”冲突，生产者还未完全把任务送到任务队列，消费者就已经在取这个任务了，就导致读到不完整的数据。3.防止“空队列”或者“满队列”竞争，队列是空还是满需要专门的检测，状态的检测和队列的更新是分开操作，需要分开，如果没有锁，可能队列已经满了，但是还没来得及更新状态，但是生产者取了状态信息认为没有满，然后继续添加导致溢出。同样的情况也在任务队列空的时候。

Test08 C++11跨平台线程池的实现

有一个存储着任务的队列，我们提前创建好的线程池不停的去执行这些任务，线程池存在的意义是因为线程的创建和销毁都是很耗费资源时间的，所以我提前弄好就不用消耗这些，提高效率

问题描述：
在这里插入图片描述

线程池的实现（使用了C++11的新特性）：

#include<iostream>
#include<thread>
#include<string>
#include<mutex>
#include<condition_variable>
#include<queue>
#include<vector>
#include<functional>using namespace std;class ThreadPool {
public:ThreadPool(int numThreads) :stop(false){for (int i = 0; i < numThreads; i++){threads.emplace_back([this]{while (1){unique_lock<mutex>lock(mtx);condition.wait(lock, [this]{return !tasks.empty() || stop;});if (stop && tasks.empty()){return;}function<void()> task(move(tasks.front()));tasks.pop();lock.unlock();task();}});}}~ThreadPool() {{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){function<void()>task = bind(forward<F>(f), forward<Args>(args)...);{unique_lock < mutex>lock(mtx);tasks.emplace(move(task));}condition.notify_one();}private:vector<thread> threads;queue<function<void()>> tasks;mutex mtx;condition_variable condition;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(chrono::seconds(1));cout << "task: " << i << "is done" << endl;});}system("pause");return 0;}

运行截图：
在这里插入图片描述
注： 八手动解锁关了就能解决打印混乱的问题
参考文献：程序员陈子青-C++11 多线程编程-小白零基础到手撕线程池-哔哩哔哩

这篇关于C++11线程池、多线程编程（附源码）的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1146501。

相关文章

C++初始化数组的几种常见方法(简单易懂)

C++初始化数组的几种常见方法(简单易懂)

《C++初始化数组的几种常见方法(简单易懂)》本文介绍了C++中数组的初始化方法,包括一维数组和二维数组的初始化,以及用new动态初始化数组,在C++11及以上版本中,还提供了使用std::array... 目录1、初始化一维数组1.1、使用列表初始化（推荐方式）1.2、初始化部分列表1.3、使用std::
阅读更多...
C++ Primer 多维数组的使用

C++ Primer 多维数组的使用

《C++Primer多维数组的使用》本文主要介绍了多维数组在C++语言中的定义、初始化、下标引用以及使用范围for语句处理多维数组的方法,具有一定的参考价值,感兴趣的可以了解一下... 目录多维数组多维数组的初始化多维数组的下标引用使用范围for语句处理多维数组指针和多维数组多维数组严格来说,C++语言没
阅读更多...
SpringBoot中使用 ThreadLocal 进行多线程上下文管理及注意事项小结

SpringBoot中使用 ThreadLocal 进行多线程上下文管理及注意事项小结

《SpringBoot中使用ThreadLocal进行多线程上下文管理及注意事项小结》本文详细介绍了ThreadLocal的原理、使用场景和示例代码,并在SpringBoot中使用ThreadLo... 目录前言技术积累1.什么是 ThreadLocal2. ThreadLocal 的原理2.1 线程隔离2
阅读更多...
Java多线程父线程向子线程传值问题及解决

Java多线程父线程向子线程传值问题及解决

《Java多线程父线程向子线程传值问题及解决》文章总结了5种解决父子之间数据传递困扰的解决方案,包括ThreadLocal+TaskDecorator、UserUtils、CustomTaskDeco... 目录1 背景2 ThreadLocal+TaskDecorator3 RequestContextH
阅读更多...
java父子线程之间实现共享传递数据

java父子线程之间实现共享传递数据

《java父子线程之间实现共享传递数据》本文介绍了Java中父子线程间共享传递数据的几种方法,包括ThreadLocal变量、并发集合和内存队列或消息队列,并提醒注意并发安全问题... 目录通过 ThreadLocal 变量共享数据通过并发集合共享数据通过内存队列或消息队列共享数据注意并发安全问题总结在 J
阅读更多...
c++中std::placeholders的使用方法

c++中std::placeholders的使用方法

《c++中std::placeholders的使用方法》std::placeholders是C++标准库中的一个工具,用于在函数对象绑定时创建占位符,本文就来详细的介绍一下,具有一定的参考价值,感兴... 目录1. 基本概念2. 使用场景3. 示例示例 1：部分参数绑定示例 2：参数重排序4. 注意事项5.
阅读更多...
使用C++将处理后的信号保存为PNG和TIFF格式

使用C++将处理后的信号保存为PNG和TIFF格式

《使用C++将处理后的信号保存为PNG和TIFF格式》在信号处理领域,我们常常需要将处理结果以图像的形式保存下来,方便后续分析和展示,C++提供了多种库来处理图像数据,本文将介绍如何使用stb_ima... 目录1. PNG格式保存使用stb_imagephp_write库1.1 安装和包含库1.2 代码解
阅读更多...
C++实现封装的顺序表的操作与实践

C++实现封装的顺序表的操作与实践

《C++实现封装的顺序表的操作与实践》在程序设计中,顺序表是一种常见的线性数据结构,通常用于存储具有固定顺序的元素,与链表不同,顺序表中的元素是连续存储的,因此访问速度较快,但插入和删除操作的效率可能... 目录一、顺序表的基本概念二、顺序表类的设计1. 顺序表类的成员变量2. 构造函数和析构函数三、顺序表
阅读更多...
使用C++实现单链表的操作与实践

使用C++实现单链表的操作与实践

《使用C++实现单链表的操作与实践》在程序设计中,链表是一种常见的数据结构,特别是在动态数据管理、频繁插入和删除元素的场景中,链表相比于数组,具有更高的灵活性和高效性,尤其是在需要频繁修改数据结构的应... 目录一、单链表的基本概念二、单链表类的设计1. 节点的定义2. 链表的类定义三、单链表的操作实现四、
阅读更多...
异步线程traceId如何实现传递

异步线程traceId如何实现传递

《异步线程traceId如何实现传递》文章介绍了如何在异步请求中传递traceId,通过重写ThreadPoolTaskExecutor的方法和实现TaskDecorator接口来增强线程池,确保异步... 目录前言重写ThreadPoolTaskExecutor中方法线程池增强总结前言在日常问题排查中，
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2