线程池学习

本文详细介绍了线程池的工作原理,包括线程池的主要组成部分,如核心线程池大小、最大线程数、线程存活时间等参数的作用,以及线程池如何通过任务队列管理和调度任务。并通过一个具体的Java示例,展示了ThreadPoolExecutor类的使用方法。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

1、百度百科

线程池是一种多线程处理形式,处理过程中将任务添加到队列,然后在创建线程后自动启动这些任务。线程池线程都是后台线程。每个线程都使用默认的堆栈大小,以默认的优先级运行,并处于多线程单元中。如果某个线程在托管代码中空闲(如正在等待某个事件),则线程池将插入另一个辅助线程来使所有处理器保持繁忙。如果所有线程池线程都始终保持繁忙,但队列中包含挂起的工作,则线程池将在一段时间后创建另一个辅助线程但线程的数目永远不会超过最大值。超过最大值的线程可以排队,但他们要等到其他线程完成后才启动。


2、ThreadPoolExecutor类

在ThreadPoolExecutor类中提供了四个构造方法:
在这里插入图片描述
构造器中各个参数的含义:
corePoolSize:核心池的大小,这个参数跟后面讲述的线程池的实现原理有非常大的关系。在创建了线程池后,默认情况下,线程池中并没有任何线程,而是等待有任务到来才创建线程去执行任务,除非调用了prestartAllCoreThreads()或者prestartCoreThread()方法,从这2个方法的名字就可以看出,是预创建线程的意思,即在没有任务到来之前就创建corePoolSize个线程或者一个线程。默认情况下,在创建了线程池后,线程池中的线程数为0,当有任务来之后,就会创建一个线程去执行任务,当线程池中的线程数目达到corePoolSize后,就会把到达的任务放到缓存队列当中;
maximumPoolSize:线程池最大线程数,这个参数也是一个非常重要的参数,它表示在线程池中最多能创建多少个线程;
keepAliveTime:表示线程没有任务执行时最多保持多久时间会终止。默认情况下,只有当线程池中的线程数大于corePoolSize时,keepAliveTime才会起作用,直到线程池中的线程数不大于corePoolSize,即当线程池中的线程数大于corePoolSize时,如果一个线程空闲的时间达到keepAliveTime,则会终止,直到线程池中的线程数不超过corePoolSize。但是如果调用了allowCoreThreadTimeOut(boolean)方法,在线程池中的线程数不大于corePoolSize时,keepAliveTime参数也会起作用,直到线程池中的线程数为0;
unit:参数keepAliveTime的时间单位
workQueue:一个阻塞队列,用来存储等待执行的任务,这个参数的选择也很重要,会对线程池的运行过程产生重大影响

3、举例测试

public class ExcutorService {
    public static void main(String[] args) {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 200, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<>(5));

        for (int i = 0; i < 15; i++) {
            MyTask myTask = new MyTask(i);
            executor.execute(myTask);
            System.out.println("线程池中线程数目:" + executor.getPoolSize() + ",队列中等待执行的任务数目:" +
                    executor.getQueue().size() + ",已执行玩别的任务数目:" + executor.getCompletedTaskCount());
        }
        executor.shutdown();
    }
}

public class MyTask implements Runnable {
    private int taskNum;
    public MyTask(int num) {
        this.taskNum = num;
    }
    @Override
    public void run() {
        System.out.println("正在执行task " + taskNum);
        try {
            Thread.sleep(4000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("task " + taskNum + "执行完毕");
    }
}

借鉴博客:https://www.cnblogs.com/dolphin0520/p/3932921.html

### C++ 线程池的实现与使用 #### 1. 线程池的概念 线程池是一种用于管理多个任务并行执行的技术。它通过预先创建一组工作线程来处理提交的任务,从而减少频繁创建和销毁线程带来的开销[^2]。线程池的核心目标是提高程序性能,尤其是在高并发场景下。 --- #### 2. 基于C++11的线程池设计 现代C++提供了丰富的多线程支持工具,例如`std::thread`, `std::mutex`, `std::condition_variable`等。这些工具使得我们可以高效地实现一个功能完善的线程池[^3]。 以下是线程池的主要组成部分: - **任务队列**:存储待执行的任务。 - **工作线程集合**:负责从任务队列中取出任务并执行。 - **同步机制**:确保线程安全访问共享资源(如任务队列)。 - **停止标志**:控制线程池的生命周期。 --- #### 3. 线程池的关键技术点 为了更好地理解和实现线程池,我们需要掌握以下几个关键技术点: ##### (1) 使用`std::function`封装任务 `std::function`可以用来封装任意可调用对象(如函数指针、lambda表达式、绑定器等),这使得我们的线程池能够接受多种形式的任务。 ```cpp using Task = std::function<void()>; ``` ##### (2) 条件变量与互斥锁 条件变量(`std::condition_variable`)和互斥锁(`std::mutex`)共同协作,确保线程等待有任务可用时不会浪费CPU资源[^2]。 ```cpp std::queue<Task> tasks; std::mutex queue_mutex; std::condition_variable condition; bool stop = false; ``` ##### (3) 工作线程循环 每个工作线程在一个无限循环中运行,直到收到停止信号为止。每次迭代都会尝试从任务队列中取任务并执行[^4]。 ```cpp void WorkerLoop() { while (!stop) { Task task; { std::unique_lock<std::mutex> lock(queue_mutex); condition.wait(lock, [this]() { return !tasks.empty() || stop; }); if (stop && tasks.empty()) break; task = std::move(tasks.front()); tasks.pop(); } task(); } } ``` --- #### 4. 完整的线程池实现 下面是一个简单的线程池实现示例,涵盖了初始化、启动、提交任务以及关闭等功能[^4]。 ```cpp #include <iostream> #include <vector> #include <thread> #include <queue> #include <functional> #include <memory> #include <future> #include <stdexcept> class ThreadPool { public: explicit ThreadPool(size_t threads_num) : stop(false) { for (size_t i = 0; i < threads_num; ++i) { workers.emplace_back([this] { this->WorkerLoop(); }); } } template<class F, class... Args> auto exec(F&& f, Args&&... args) -> std::future<decltype(f(args...))> { using ReturnType = decltype(f(args...)); auto task = std::make_shared<std::packaged_task<ReturnType()>>(std::bind(std::forward<F>(f), std::forward<Args>(args)...)); std::future<ReturnType> res = task->get_future(); { std::lock_guard<std::mutex> lock(queue_mutex); if (stop) throw std::runtime_error("Thread pool is stopped"); tasks.emplace([task]() { (*task)(); }); } condition.notify_one(); return res; } ~ThreadPool() { { std::unique_lock<std::mutex> lock(queue_mutex); stop = true; } condition.notify_all(); for (auto& worker : workers) { if (worker.joinable()) worker.join(); } } private: void WorkerLoop() { while (!stop) { Task task; { std::unique_lock<std::mutex> lock(queue_mutex); condition.wait(lock, [this]() { return !tasks.empty() || stop; }); if (stop && tasks.empty()) break; task = std::move(tasks.front()); tasks.pop(); } task(); } } using Task = std::function<void()>; std::vector<std::thread> workers; std::queue<Task> tasks; std::mutex queue_mutex; std::condition_variable condition; bool stop; }; // 测试代码 int main() { ThreadPool pool(4); auto future1 = pool.exec([](int a) { return a * 2; }, 5); auto future2 = pool.exec([](double b) { return b / 3.0; }, 9.0); std::cout << "Result of first task: " << future1.get() << std::endl; std::cout << "Result of second task: " << future2.get() << std::endl; return 0; } ``` --- #### 5. 如何使用线程池 要使用上述线程池类,只需实例化一个`ThreadPool`对象,并通过其成员函数`exec()`提交任务即可。该方法返回一个`std::future`对象,允许我们在主线程中异步获取任务的结果[^4]。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值