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。

相关文章

SpringBoot分段处理List集合多线程批量插入数据方式

SpringBoot分段处理List集合多线程批量插入数据方式

《SpringBoot分段处理List集合多线程批量插入数据方式》文章介绍如何处理大数据量List批量插入数据库的优化方案：通过拆分List并分配独立线程处理,结合Spring线程池与异步方法提升效率... 目录项目场景解决方案1.实体类2.Mapper3.spring容器注入线程池bejsan对象4.创建
阅读更多...
C++右移运算符的一个小坑及解决

C++右移运算符的一个小坑及解决

《C++右移运算符的一个小坑及解决》文章指出右移运算符处理负数时左侧补1导致死循环,与除法行为不同,强调需注意补码机制以正确统计二进制1的个数... 目录我遇到了这么一个www.chinasem.cn函数由此可以看到也很好理解总结我遇到了这么一个函数template<typename T>unsigned
阅读更多...
MySQL的JDBC编程详解

MySQL的JDBC编程详解

《MySQL的JDBC编程详解》：本文主要介绍MySQL的JDBC编程,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录前言一、前置知识1. 引入依赖2. 认识 url二、JDBC 操作流程1. JDBC 的写操作2. JDBC 的读操作总结前言本文介绍了mysq
阅读更多...
C++统计函数执行时间的最佳实践

C++统计函数执行时间的最佳实践

《C++统计函数执行时间的最佳实践》在软件开发过程中,性能分析是优化程序的重要环节,了解函数的执行时间分布对于识别性能瓶颈至关重要,本文将分享一个C++函数执行时间统计工具,希望对大家有所帮助... 目录前言工具特性核心设计1. 数据结构设计2. 单例模式管理器3. RAII自动计时使用方法基本用法高级用法
阅读更多...
Java中如何正确的停掉线程

Java中如何正确的停掉线程

《Java中如何正确的停掉线程》Java通过interrupt()通知线程停止而非强制,确保线程自主处理中断,避免数据损坏,线程池的shutdown()等待任务完成,shutdownNow()强制中断... 目录为什么不强制停止为什么 Java 不提供强制停止线程的能力呢？如何用interrupt停止线程s
阅读更多...
深入解析C++ 中std::map内存管理

深入解析C++ 中std::map内存管理

《深入解析C++中std::map内存管理》文章详解C++std::map内存管理,指出clear()仅删除元素可能不释放底层内存,建议用swap()与空map交换以彻底释放,针对指针类型需手动de... 目录1️、基本清空std::map2️、使用 swap 彻底释放内存3️、map 中存储指针类型的对象
阅读更多...
python 线程池顺序执行的方法实现

python 线程池顺序执行的方法实现

《python线程池顺序执行的方法实现》在Python中,线程池默认是并发执行任务的,但若需要实现任务的顺序执行,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋... 目录方案一：强制单线程（伪顺序执行）方案二：按提交顺序获取结果方案三：任务间依赖控制方案四：队列顺序消
阅读更多...
Python异步编程之await与asyncio基本用法详解

Python异步编程之await与asyncio基本用法详解

《Python异步编程之await与asyncio基本用法详解》在Python中,await和asyncio是异步编程的核心工具,用于高效处理I/O密集型任务（如网络请求、文件读写、数据库操作等）,接... 目录一、核心概念二、使用场景三、基本用法1. 定义协程2. 运行协程3. 并发执行多个任务四、关键
阅读更多...
Python多线程实现大文件快速下载的代码实现

Python多线程实现大文件快速下载的代码实现

《Python多线程实现大文件快速下载的代码实现》在互联网时代,文件下载是日常操作之一,尤其是大文件,然而,网络条件不稳定或带宽有限时,下载速度会变得很慢,本文将介绍如何使用Python实现多线程下载... 目录引言一、多线程下载原理二、python实现多线程下载代码说明：三、实战案例四、注意事项五、总结引
阅读更多...
AOP编程的基本概念与idea编辑器的配合体验过程

AOP编程的基本概念与idea编辑器的配合体验过程

《AOP编程的基本概念与idea编辑器的配合体验过程》文章简要介绍了AOP基础概念,包括Before/Around通知、PointCut切入点、Advice通知体、JoinPoint连接点等,说明它们... 目录BeforeAroundAdvise — 通知PointCut — 切入点Acpect — 切面
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2