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++ 函数 strftime 和时间格式示例详解

C++ 函数 strftime 和时间格式示例详解

《C++函数strftime和时间格式示例详解》strftime是C/C++标准库中用于格式化日期和时间的函数,定义在ctime头文件中,它将tm结构体中的时间信息转换为指定格式的字符串,是处理... 目录C++ 函数 strftipythonme 详解一、函数原型二、功能描述三、格式字符串说明四、返回值五
阅读更多...
Java中实现线程的创建和启动的方法

Java中实现线程的创建和启动的方法

《Java中实现线程的创建和启动的方法》在Java中,实现线程的创建和启动是两个不同但紧密相关的概念,理解为什么要启动线程（调用start()方法）而非直接调用run()方法,是掌握多线程编程的关键,... 目录1. 线程的生命周期2. start() vs run() 的本质区别3. 为什么必须通过 st
阅读更多...
C++作用域和标识符查找规则详解

C++作用域和标识符查找规则详解

《C++作用域和标识符查找规则详解》在C++中,作用域（Scope）和标识符查找（IdentifierLookup）是理解代码行为的重要概念,本文将详细介绍这些规则,并通过实例来说明它们的工作原理,需... 目录作用域标识符查找规则1. 普通查找（Ordinary Lookup）2. 限定查找（Qualif
阅读更多...
Linux实现线程同步的多种方式汇总

Linux实现线程同步的多种方式汇总

《Linux实现线程同步的多种方式汇总》本文详细介绍了Linux下线程同步的多种方法,包括互斥锁、自旋锁、信号量以及它们的使用示例,通过这些同步机制,可以解决线程安全问题,防止资源竞争导致的错误,示例... 目录什么是线程同步？一、互斥锁（单人洗手间规则）适用场景：特点：二、条件变量（咖啡厅取餐系统）工作流
阅读更多...
Java中常见队列举例详解(非线程安全)

Java中常见队列举例详解(非线程安全)

《Java中常见队列举例详解(非线程安全)》队列用于模拟队列这种数据结构,队列通常是指先进先出的容器,：本文主要介绍Java中常见队列(非线程安全)的相关资料,文中通过代码介绍的非常详细,需要的朋... 目录一.队列定义 二.常见接口 三.常见实现类3.1 ArrayDeque3.1.1 实现原理3.1.2
阅读更多...
SpringBoot3中使用虚拟线程的完整步骤

SpringBoot3中使用虚拟线程的完整步骤

《SpringBoot3中使用虚拟线程的完整步骤》在SpringBoot3中使用Java21+的虚拟线程（VirtualThreads）可以显著提升I/O密集型应用的并发能力,这篇文章为大家介绍了详细... 目录1. 环境准备2. 配置虚拟线程方式一：全局启用虚拟线程（Tomcat/Jetty）方式二：异步
阅读更多...
如何解决Druid线程池Cause:java.sql.SQLRecoverableException:IO错误:Socket read timed out的问题

如何解决Druid线程池Cause:java.sql.SQLRecoverableException:IO错误:Socket read timed out的问题

《如何解决Druid线程池Cause:java.sql.SQLRecoverableException:IO错误:Socketreadtimedout的问题》：本文主要介绍解决Druid线程... 目录异常信息触发场景找到版本发布更新的说明从版本更新信息可以看到该默认逻辑已经去除总结异常信息触发场景复
阅读更多...
C/C++ chrono简单使用场景示例详解

C/C++ chrono简单使用场景示例详解

《C/C++chrono简单使用场景示例详解》：本文主要介绍C/C++chrono简单使用场景示例详解,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友... 目录chrono使用场景举例1 输出格式化字符串chrono使用场景China编程举例1 输出格式化字符串示
阅读更多...
C++/类与对象/默认成员函数@构造函数的用法

C++/类与对象/默认成员函数@构造函数的用法

《C++/类与对象/默认成员函数@构造函数的用法》：本文主要介绍C++/类与对象/默认成员函数@构造函数的用法,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录名词概念默认成员函数构造函数概念函数特征显示构造函数隐式构造函数总结名词概念默认构造函数：不用传参就可以
阅读更多...
C++类和对象之默认成员函数的使用解读

C++类和对象之默认成员函数的使用解读

《C++类和对象之默认成员函数的使用解读》：本文主要介绍C++类和对象之默认成员函数的使用方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录一、默认成员函数有哪些二、各默认成员函数详解默认构造函数析构函数拷贝构造函数拷贝赋值运算符三、默认成员函数的注意事项总结一
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2