ThreadPoolExecutor 使用示例，请给出详细代码

### 回答1：

示例代码如下：from concurrent.futures import ThreadPoolExecutordef my_func(x):
return x * xwith ThreadPoolExecutor(max_workers=3) as executor:
# Submit work to the executor
future = executor.submit(my_func, 2) # Wait for the results
print(future.result())

### 回答2：
ThreadPoolExecutor 是 Java 中的一个线程池实现类，通过它可以进行线程的复用和线程的管理。下面是一个使用 ThreadPoolExecutor 的示例代码：

import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadPoolExample {
    public static void main(String[] args) {
        // 创建一个线程池，设置核心线程数为2，最大线程数为4，空闲线程保活时间为10秒，使用无界的阻塞队列作为任务队列
        ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 4, 10, TimeUnit.SECONDS, new LinkedBlockingQueue<>());

        // 提交任务给线程池执行
        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            executor.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println("Task " + taskId + " is running in " + Thread.currentThread().getName());
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }

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

在这个示例中，我们创建了一个 ThreadPoolExecutor 对象，设置核心线程数为2，最大线程数为4。当提交的任务数量超过核心线程数时，多余的任务会被放入阻塞队列中等待执行。如果阻塞队列已满且线程数未达到最大线程数，新任务会创建新的线程进行执行。同时，空闲线程的保活时间设置为10秒，即如果线程在空闲状态超过10秒，会被自动销毁。

在示例中，我们提交了10个任务给线程池执行，每个任务的执行时间为1秒。当任务被执行时，会打印出任务的编号和执行线程的名称。最后，我们调用了线程池的 shutdown() 方法来关闭线程池，这会等待所有任务执行完成并销毁所有线程。

### 回答3：
ThreadPoolExecutor 是一个线程池执行器，它可以管理和执行多个线程任务，提供了对线程池的调度和控制功能，可以帮助我们更好地利用线程资源。

下面是一个简单的 ThreadPoolExecutor 使用示例的详细代码：

import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadPoolExecutorExample {
    public static void main(String[] args) {
        // 创建线程池执行器，设置核心线程数为2，最大线程数为4，空闲线程超时时间为1秒
        ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(2);

        // 创建10个任务并提交给线程池执行
        for (int i = 0; i < 10; i++) {
            Runnable task = new Task("Task " + i);
            System.out.println("提交任务：" + task);
            executor.execute(task);
        }

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

class Task implements Runnable {
    private String name;

    public Task(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        try {
            System.out.println("开始执行任务：" + name);
            // 模拟任务执行耗时
            TimeUnit.SECONDS.sleep(2);
            System.out.println("完成任务：" + name);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public String toString() {
        return "Task{" +
                "name='" + name + '\'' +
                '}';
    }
}

以上代码中，首先创建了一个 ThreadPoolExecutor 对象，核心线程数为2，最大线程数为4，空闲线程超时时间为1秒。

然后，创建了10个任务并提交给线程池执行，每个任务是一个简单的 Runnable 对象，表示执行一个任务。

任务开始执行时，会打印开始执行任务的信息，然后模拟任务执行耗时2秒，完成任务后打印完成任务的信息。

最后，调用线程池执行器的 shutdown() 方法关闭线程池执行器。