写一个线程池，异步调用

代码如下：

import concurrent.futures

def worker(num):
    print(f"Worker {num} starting")
    return

if __name__ == "__main__":
    with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
        for i in range(5):
            executor.submit(worker, i)

这段代码实现了一个具有 5 个线程的线程池，并使用线程池异步调用了 worker 函数。具体地，每个线程会输出自己的编号，说明这个线程已经开始运行。

相关问题

Java 写一个线程池异步执行一个方法

可以使用 Java 自带的 Executor 框架来实现线程池异步执行方法。以下是一个示例代码：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Example {
    public static void main(String[] args) {
        // 创建一个线程池，包含固定数量的线程
        ExecutorService executor = Executors.newFixedThreadPool(5);

        // 异步执行一个方法
        executor.submit(() -> {
            // 这里是需要异步执行的方法
            System.out.println("异步执行的方法");
        });

        // 关闭线程池
        executor.shutdown();
    }
}

在上面的代码中，我们首先创建一个 ExecutorService 对象，并通过 Executors.newFixedThreadPool() 方法指定了线程池的大小为 5。然后通过 executor.submit() 方法将需要异步执行的方法包装成一个 Runnable 对象传入，线程池会自动分配一个空闲线程执行该方法。最后调用 executor.shutdown() 方法关闭线程池。

c++线程池异步调用

以下是一个使用C++线程池进行异步调用的示例：

#include <iostream>
#include <thread>
#include <functional>
#include <vector>
#include <queue>
#include <mutex>
#include <condition_variable>

class ThreadPool {
public:
    ThreadPool(size_t numThreads) : stop(false) {
        for (size_t i = 0; i < numThreads; ++i) {
            threads.emplace_back([this] {
                while (true) {
                    std::function<void()> task;
                    {
                        std::unique_lock<std::mutex> lock(queueMutex);
                        condition.wait(lock, [this] { return stop || !tasks.empty(); });
                        if (stop && tasks.empty()) {
                            return;
                        }
                        task = std::move(tasks.front());
                        tasks.pop();
                    }
                    task();
                }
            });
        }
    }

    template<class F, class... Args>
    void enqueue(F&& f, Args&&... args) {
        {
            std::unique_lock<std::mutex> lock(queueMutex);
            tasks.emplace([=] { std::invoke(f, args...); });
        }
        condition.notify_one();
    }

    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(queueMutex);
            stop = true;
        }
        condition.notify_all();
        for (std::thread& thread : threads) {
            thread.join();
        }
    }

private:
    std::vector<std::thread> threads;
    std::queue<std::function<void()>> tasks;
    std::mutex queueMutex;
    std::condition_variable condition;
    bool stop;
};

// 示例任务函数
void printHello(int id) {
    std::cout << "Hello from thread " << id << std::endl;
}

int main() {
    ThreadPool pool(4); // 创建一个拥有4个线程的线程池

    // 向线程池中添加任务
    for (int i = 0; i < 10; ++i) {
        pool.enqueue(printHello, i);
    }

    // 等待所有任务完成
    // 这里不需要使用pthread_join函数，线程池会自动处理任务的执行和完成
    // 当线程池析构时，会等待所有任务完成后再退出
    // 所以在这里不需要显式地调用join函数
    // 但是需要注意的是，如果在线程池析构前没有等待所有任务完成，可能会导致任务被中断
    // 所以在实际使用中，需要根据具体情况来决定何时销毁线程池

    return 0;
}