C++之线程、线程池

已于 2024-08-10 23:14:31 修改
阅读量765 收藏 5
点赞数 6
分类专栏： C/C++共同学习 文章标签： c++ 开发语言 深度优先
于 2024-03-16 18:11:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_34486832/article/details/136749272
版权

1、C++线程基础

        在C++11之前，C++语言没有引入线程的概念，但是可以借助操作系统平台提供的API，比如Linux的<pthread.h>或者Windows下的<windows.h> 来实现多线程。

        在C++11之后，C++提供了语言层面上的多线程支持，头文件thread.h。解决了跨平台（Linux、Windows）的问题，提供了管理线程、保护共享数据、线程间同步操作、原子操作等。

thread.h和pthread.h的区别：
        （1）pthread.h是POSIX线程标准的头文件，而thread.h是C++11标准中的线程库头文件。
        （2）pthread.h适用于C语言和C++语言，而thread.h只适用于C++语言。
        （3）pthread.h中使用的函数和类型更加底层，需要手动管理线程的创建、销毁、同步等操作，而thread.h中的线程库提供了更高层次的抽象，使得线程编程更加方便和安全。
        （4）pthread.h中的线程库具有更好的移植性，可以在各种Unix系统上使用，而thread.h的支持范围相对较小。
        （5）如果你是在C++11标准下进行线程编程，建议使用thread.h。如果你需要更底层的控制或者需要在多种Unix系统上移植代码，可以选择使用pthread.h。

2、thread类

2.1、创建线程

创建线程举例：        

        创建线程：需要把【线程处理函数】添加到【线程】当中。

形式1：
std::thread myThread(thread_function);
myThread.join();
// 线程处理函数形式为：void thread_function()
// 同一个函数可以代码复用，创建多个线程


形式2：
std::thread myThread(thread_function(100));
myThread.join();
//函数形式为：void thread_function(int x)
//同一个函数可以代码复用，创建多个线程


形式3：
std::thread(thread_function, 1).detach();
// 直接创建线程，没有名字
// 函数形式为void thread_function(int x)

代码：

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

void thread_function_1()
{
    cout << "thread_function_1!" << endl;
}

void thread_function_2(int x)
{
    cout << "thread_function_2! " << x << endl;
}

int main ()
{
    std::thread thread_1(thread_function_1);
    thread_1.join();

    std::thread thread_2(thread_function_2, 100);
    thread_2.join();

    cout << "main!" << endl;
    return 0;
}

结果：

thread_function_1!
thread_function_2! 100
main!

线程构造函数详细介绍：

        std::thread 在 <thread> 头文件中声明，因此使用 std::thread 时需要包含 <thread> 头文件。其中std::thread 构造方法如下：

默认构造函数     thread() noexcept;
初始化构造函数 template <class Fn, class... Args>
拷贝构造函数 thread (const thread&) = delete;
move构造函数 thread (thread&& x) noexcept;

（1）默认构造函数：创建一个空thread对象，该对象非joinable。

（2）初始化构造函数：创建一个thread对象，该对象会调用Fn函数，Fn函数的参数由args指定，该对象是joinable的。

（3）拷贝构造函数：被禁用，意味着thread对象不可拷贝构造。

（4）move构造函数：移动构造，执行成功之后x失效，即x的执行信息被移动到新产生的thread对象，该对象非joinable。

代码：

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

void thread_function_2(int n)
{
	for (int i = 0; i < 5; ++i) {
		cout << "thread_function_2: i = " << i << endl;
		std::this_thread::sleep_for(std::chrono::milliseconds(10));
	}
}
 
void thread_function_3(int& n)
{
	for (int i = 0; i < 5; ++i) {
		cout << "thread_function_3: i = " << i << endl;
		++n;
		std::this_thread::sleep_for(std::chrono::milliseconds(10));
	}
}
 
int main()
{
	int num = 0;
	std::thread thread_1; // thread_1 is not a thread
	
	std::thread thread_2(thread_function_2, num + 1);       // pass by value
	std::thread thread_3(thread_function_3, std::ref(num)); // pass by reference
	std::thread thread_4(std::move(thread_3));              // thread_4 is now running thread_function_3(). thread_3 is no longer a thread
	//thread_1.join();  崩溃
	thread_2.join();
	//thread_3.join();  崩溃; 因为thread_3已经move到thread_4
	thread_4.join();
	cout << "Final value of num is " << num << endl;
}

结果：

thread_function_2: i = thread_function_3: i = 00

thread_function_2: i = 1
thread_function_3: i = 1
thread_function_2: i = 2
thread_function_3: i = 2
thread_function_3: i = thread_function_2: i = 33

thread_function_2: i = 4
thread_function_3: i = 4
Final value of num is 5

一个thread对象是否是joinable的判断方式：

（1） 如果一个线程正在执行，那么它是jionable的。

（2）下列任一情况，都是非joinable：

        （1）默认构造器构造的。

        （2）通过移动构造获得的。

        （3）调用了join或者detach方法的。

当线程启动后，一定要确定以什么方式结束：

        （1）detach方式，启动的线程自主在后台运行，当前的代码继续往下执行，不等待新线程结束。

        （2）join方式，等待启动的线程完成，才会继续往下执行。

2.2、join()函数

        调用join()函数后，当前线程阻塞等待子线程结束后继续执行。

代码：

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

void thread_function_1()
{
    for (int i = 0; i < 10; ++i) {
        cout << "thread_function_1!  " << i << endl;
    }
}

void thread_function_2(int x)
{
    for (int i = 0; i < 10; ++i) {
        cout << "thread_function_2!  " << i << "  " << x << endl;
    }
}

int main ()
{
    std::thread thread_1(thread_function_1);
    thread_1.join();
    cout << "thread_1 over!" << endl;

    std::thread thread_2(thread_function_2, 100);
    thread_2.join();
    cout << "thread_2 over!" << endl;

    cout << "main!" << endl;
    return 0;
}

结果：

thread_function_1!  0
thread_function_1!  1
thread_function_1!  2
thread_function_1!  3
thread_function_1!  4
thread_function_1!  5
thread_function_1!  6
thread_function_1!  7
thread_function_1!  8
thread_function_1!  9
thread_1 over!
thread_function_2!  0  100
thread_function_2!  1  100
thread_function_2!  2  100
thread_function_2!  3  100
thread_function_2!  4  100
thread_function_2!  5  100
thread_function_2!  6  100
thread_function_2!  7  100
thread_function_2!  8  100
thread_function_2!  9  100
thread_2 over!
main!

2.3、detach()函数

        调用detach()函数后，当前线程和子线程分离，不必等待子线程结束，即子线程变成守护线程。

代码：

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

void thread_function_1()
{
    for (int i = 0; i < 10; ++i) {
        cout << "thread_function_1!  " << i << endl;
    }
}

void thread_function_2(int x)
{
    for (int i = 0; i < 10; ++i) {
        cout << "thread_function_2!  " << i << "  " << x << endl;
    }
}

int main ()
{
    std::thread thread_1(thread_function_1);
    std::thread thread_2(thread_function_2, 100);

    thread_1.detach();
    thread_2.detach();

    cout << "main!" << endl;
    return 0;
}

结果：

main!thread_function_1!  thread_function_2!  00  100

thread_function_1!  
thread_function_2!  1  100
thread_function_2!  21
  100
thread_function_2!  3  100

注意：

        （1）detach()函数的作用是将线程与其父线程分离，使得子线程可以在后台继续执行而不受父线程的控制。具体来说，当调用detach()函数时，父线程不再等待子线程执行完成，而是立即返回到主线程继续执行后续的代码。这意味着子线程将在后台独立运行，直到其执行完成或终止。

        （2）调用detach()函数以后，可以理解为被分离的线程就完全独立了。但是根据《unix编程手册》的说法，主线程退出之后，这个进程中的所有线程都会被退出。本文觉得，在UNIX中主线程退出后，子线程也随之退出。

2.4、this_thread【多线程之命名空间】

        在 C++11 中不仅添加了线程类，还添加了一个关于线程的命名空间 std::this_thread，在这个命名空间中提供了四个公共的成员函数，通过这些成员函数就可以对当前线程进行相关的操作了

2.4.1、get_id()函数

        调用命名空间 std::this_thread 中的 get_id() 方法可以得到当前线程的线程 ID。

// 函数原型如下：
thread::id get_id() noexcept;

代码：

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

void thread_function_1()
{
    for (int i = 0; i < 10; ++i) {
        cout << "thread_function_1!  " << i << "  " << this_thread::get_id() << endl;
    }
}

void thread_function_2(int x)
{
    for (int i = 0; i < 10; ++i) {
        cout << "thread_function_2!  " << i << "  " << x << "  " << this_thread::get_id() << endl;
    }
}

int main ()
{
    std::thread thread_1(thread_function_1);
    thread_1.join();
    cout << "thread_1 over!" << endl;

    std::thread thread_2(thread_function_2, 100);
    thread_2.join();
    cout << "thread_2 over!" << endl;

    cout << "main!" << endl;
    return 0;
}

结果：

thread_function_1!  0  140719225247488
thread_function_1!  1  140719225247488
thread_function_1!  2  140719225247488
thread_function_1!  3  140719225247488
thread_function_1!  4  140719225247488
thread_function_1!  5  140719225247488
thread_function_1!  6  140719225247488
thread_function_1!  7  140719225247488
thread_function_1!  8  140719225247488
thread_function_1!  9  140719225247488
thread_1 over!
thread_function_2!  0  100  140719225247488
thread_function_2!  1  100  140719225247488
thread_function_2!  2  100  140719225247488
thread_function_2!  3  100  140719225247488
thread_function_2!  4  100  140719225247488
thread_function_2!  5  100  140719225247488
thread_function_2!  6  100  140719225247488
thread_function_2!  7  100  140719225247488
thread_function_2!  8  100  140719225247488
thread_function_2!  9  100  140719225247488
thread_2 over!
main!

2.4.2、sleep_for()函数

        由于进程被创建后就有5种状态，所以同样的线程被创建后也有这五种状态：创建态，就绪态，运行态，阻塞态(挂起态)，退出态(终止态)。

        线程和进程的执行有很多相似之处，在计算机中启动的多个线程都需要占用 CPU 资源，但是 CPU 的个数是有限的并且每个 CPU 在同一时间点不能同时处理多个任务。为了能够实现并发处理，多个线程都是分时复用CPU时间片，快速的交替处理各个线程中的任务。        因此多个线程之间需要争抢CPU时间片，抢到了就执行，抢不到则无法执行（因为默认所有的线程优先级都相同，内核也会从中调度，不会出现某个线程永远抢不到 CPU 时间片的情况）。

        命名空间 this_thread 中提供了一个休眠函数 sleep_for()，调用这个函数的线程会马上从运行态变成阻塞态并在这种状态下休眠一定的时长，因为阻塞态的线程已经让出了 CPU 资源，代码也不会被执行，所以线程休眠过程中对 CPU 来说没有任何负担。

// 函数原型如下，参数需要指定一个休眠时长，是一个时间段
template <class Rep, class Period>
  void sleep_for (const chrono::duration<Rep,Period>& rel_time);

代码：

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

void thread_function_1()
{
    for (int i = 0; i < 10; ++i) {
        cout << "thread_function_1!  " << i << "  " << this_thread::get_id() << endl;
		std::this_thread::sleep_for(std::chrono::milliseconds(10));  // sleep 10ms
    }
}
最低0.47元/天 解锁文章
C++线程
2301_79274600的博客
08-26 1545
如果共享数据都是只读的，那么没问题，因为只读操作不会影响到数据，更不会涉及对数据的修改，所以所有线程都会获得同样的数据。（但通常不推荐）：虽然std::unique_lock对象在技术上是可以复制和移动的，但这种操作会释放原始锁并获取新锁（或保持无锁状态），这通常不是期望的行为，因此在实际使用中应谨慎。虽然加锁可以解决，但是加锁有一个缺陷就是：只要一个线程在对sum++时，其他线程就会被阻塞，会影响程序运行的效率，而且锁如果控制不好，还容易造成死锁。进程是系统资源分配的最小单位，是应用程序运行的环境。
C++之线程
qq_55527904的博客
02-14 911
通过线程，程序可以同时执行多个任务，从而提高性能和响应速度。上边程序的运行流程是三个线程调用执行函数，阻塞等待，等待1s后，加锁，条件满足继续执行后续函数，从而实现三个线程同步执行。线程——是操作系统能够调度的最小执行单位。使用thread创建线程，并指定线程执行的函数。condition_variable——用于实现线程间的条件变量。通过上面的简单例子，可以知道如何创建线程并指定线程执行的函数。并发——多个线程同时执行，但可能交替占用CPU资源。并行——多个线程同时执行，且同时占用多个CPU资源。
C++ 线程
Cdreamfly的博客
03-02 6852
thread 类 thread 表示单个执行线程。线程允许多个函数同时执行。 线程在构造关联的线程对象时立即开始执行（等待任何OS调度延迟），从提供给作为构造函数参数的顶层函数开始。顶层函数的返回值将被忽略，而且若它以抛异常终止，则调用 std::terminate 。顶层函数可以通过 std::promise 或通过修改共享变量（可能需要同步，见 std::mutex 与 std::atomic ）将其返回值或异常传递给调用方。 std::thread 对象也可能处于不表示任何线程的状态（默认构造、被移动
C/C++线程详解
最新发布
weixin_40026739的博客
04-25 974
C/C++线程详解
c++多线程
aocenmin8777的博客
08-02 610
C++ 多线程 多线程是多任务处理的一种特殊形式，多任务处理允许让电脑同时运行两个或两个以上的程序。一般情况下，两种类型的多任务处理：基于进程和基于线程。 基于进程的多任务处理是程序的并发执行。 基于线程的多任务处理是同一程序的片段的并发执行。 多线程程序包含可以同时运行的两个或多个部分。这样的程序中的每个部分称为一个线程，每个线程定义了一个单独的执行路径。 本...
C++中的线程
super_marie的博客
01-25 396
进程和线程的概念： 1、进程是一个正在执行的程序，是向CPU申请资源的，不同进程之间数据是相互独立的，而一个进程至少有一个线程。 2、线程是最小的控制单元，是进程中单一的顺序控制流程，是进程中的执行单元。 关于线程中的互斥锁： 方式一： Mutex mut; 一旦上锁，即调用mut.lock()函数，只有在解锁之后才能用，即调用mut.unlock()函数。 方式二： un
c++ 多线程线程池 demo
03-02
在C++编程中，多线程技术是一种提升程序性能的有效手段，特别是在处理大量并发任务时。线程池是多线程编程中一个重要的概念，它能够优化系统资源的...这有助于我们更好地理解和应用线程池，优化我们的C++多线程程序。
C++ 线程 多线程 线程池
GodJhin的博客
06-21 470
b.对线程进行管理要求额外的CPU开销，线程的使用会给系统带来上下文切换的额外负担；当有线程任务时，从池中取一个，执行完成后线程对象归池，这样可以避免反复创建线程对象所带来的性能开销，节省了系统的资源。线程：线程是操作系统调度的最小单元，每个线程都拥有各自的计数器、堆栈和局部变量等属性，在进行中负责程序执行的执行单元，多个线程组成了一个进程，一个进程中至少有一个线程。它可以在应用程序中预先创建一组线程，然后将任务分配给这些线程，以便在不同的任务之间共享线程资源，并避免不断创建和销毁线程的开销。
c++多线程线程池服务端和客户端例子
09-13
在给定的"C++多线程线程池服务端和客户端例子"中，我们可以深入探讨以下几个关键知识点： 1. **C++11多线程库**: C++11标准引入了`<thread>`库，提供了对多线程的支持。在这个例子中，我们可能会看到如何创建和管理...
C++多线程从原理到线程池实战-视频教程网盘链接提取码下载.txt
10-13
C++多线程从原理到线程池实战是一门针对C++程序员设计的课程。通过深入学习多线程的原理和技术，学生将掌握线程管理、同步与互斥、并发编程等核心概念。课程还包括线程池的设计与实践，帮助学生提高程序性能和并行...
Linux C++ 服务器之线程池 C++11
11-09
线程池是一组预先创建并处于就绪状态的线程集合，当有新的任务需要执行时，线程池会从现有的线程中选择一个而不是每次都创建新的线程。这种机制可以减少系统的上下文切换，提高程序运行效率。在C++11中，`std::...
线程池原理及创建
11-14 994
线程池原理及创建本文给出了一个通用的线程池框架，该框架将与线程执行相关的任务进行了高层次的抽象，使之与具体的执行任务无关。另外该线程池具有动态伸缩性，它能根据执行任务的轻重自动调整线程池中线程的数量。文章的最后，我们给出一个简单示例程序，通过该示例程序，我们会发现，通过该线程池框架执行多线程任务是多么的简单。为什么需要线程池目前的大多数网络服务器，包括Web服务器、Email服务器以及数据库服务器
C++ 线程池
暮色尽染的博客
07-01 1903
(来自ChatGPT)线程池是一种用于管理和复用线程的机制。它可以提高程序的性能和效率，特别是在处理大量并发任务时。线程池中包含一定数量的线程，这些线程可以重复执行多个任务。当有任务需要执行时，可以将任务提交给线程池，线程池会选择一个可用的线程来执行任务。任务执行完毕后，线程会返回线程池，等待下一个任务的到来。线程池的优点：降低线程创建和销毁的开销：线程的创建和销毁是比较耗费资源的操作，使用线程池可以避免频繁地创建和销毁线程，提高程序的性能。提高系统的响应速度。
c++ 线程
Raindrips的博客
03-06 352
线程 线程使得程序能在数个处理器核心同时执行。 定义于头文件 <thread> thread 管理单独的线程 原型 class thread; c++中的线程,相对比较安全 创建一个线程 要定义一个函数 创建一个线程对象,将函数作为参数转递 等待线程的结束 管理当前线程的函数 定义于命名空间 this_thread yield() 建议实现重新调度各执行线...
c++线程
qq_37174816的博客
08-23 1286
转载地址：https://blog.youkuaiyun.com/libaineu2004/article/details/79612619?utm_source=blogxgwz9 本文概要： 1、成员类型和成员函数。 2、std::thread 构造函数。 3、异步。 4、多线程传递参数。 5、join、detach。 6、获取CPU核心个数。 7、CPP原子变量与线程安全。 8、lambda与多线程。 9、时间等待相关问题。 10、线程功能拓展。 11、多线程可变参数。 12、线程交换.
c++ 多线程线程池
12-26
### C++ 中实现多线程和线程池的方法 #### 使用 `std::thread` 创建单个线程 在 C++ 中，可以利用标准库 `<thread>` 提供的功能来启动新的线程。通过实例化 `std::thread` 对象并传递给它要在线程内运行的目标函数或可调用对象。 ```cpp #include <iostream> #include <thread> void threadFunction(int id) { std::cout << "Thread ID, " << id << ", is running.\n"; } int main() { std::thread t(threadFunction, 1); // 主线程等待子线程结束 if (t.joinable()) { t.join(); } } ``` 这段代码展示了如何定义一个简单的线程函数，并将其作为参数传入到新创建的线程中去执行[^1]。 #### 构建基本线程池结构 为了更高效地管理和复用工作线程，在实际应用中通常会构建线程池模式。这里给出一种基于任务队列的工作窃取型线程池的设计思路： - **任务封装**：将待处理的任务打包成共享指针形式存储于阻塞队列里； - **工作者线程**：预先分配一定数量的固定线程持续监听任务列表的变化情况； - **提交接口**：对外提供便捷方法用于向内部添加新作业； 下面是简化版的具体实现方式[^4]： ```cpp #include <queue> #include <vector> #include <memory> #include <future> #include <functional> #include <exception> #include <stdexcept> #include <mutex> #include <condition_variable> #include <thread> class ThreadPool { public: explicit ThreadPool(size_t threads): stop(false){ for(size_t i = 0;i<threads;++i) workers.emplace_back( [this] { for(;;){ std::function<void()> task; { std::unique_lock<std::mutex> lock(this->queue_mutex); this->condition.wait(lock, [this]{ return this->stop || !this->tasks.empty(); }); if(this->stop && this->tasks.empty()) return; task=std::move(this->tasks.front()); this->tasks.pop(); } task(); } } ); } template<class F, class... Args> auto enqueue(F&& f, Args&&... args) -> std::future<typename std::result_of<F(Args...)>::type>{ using return_type = typename std::result_of<F(Args...)>::type; auto task = std::make_shared< std::packaged_task<return_type()> >( std::bind(std::forward<F>(f), std::forward<Args>(args)...) ); std::future<return_type> res = task->get_future(); { std::unique_lock<std::mutex> lock(queue_mutex); // 不允许再加入任务的情况 if(stop) throw std::runtime_error("enqueue on stopped ThreadPool"); tasks.emplace([task](){ (*task)(); }); } condition.notify_one(); return res; } ~ThreadPool(){ { std::unique_lock<std::mutex> lock(queue_mutex); stop=true; } condition.notify_all(); for(std::thread &worker:workers) worker.join(); } private: std::vector<std::thread> workers; std::queue<std::function<void()>> tasks; std::mutex queue_mutex; std::condition_variable condition; bool stop; }; ``` 此段程序实现了具有动态负载均衡特性的轻量级线程池框架，能够有效减少频繁创建销毁线程所带来的开销问题[^2]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值