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

### 回答1：

import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;public class ThreadPoolExecutorExample {
public static void main(String[] args){
ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(2);

for (int i = 1; i <= 5; i++) {
Task task = new Task("Task " + i);
System.out.println("Created : " + task.getName());

executor.execute(task);
}
executor.shutdown();
}
}class Task implements Runnable {
private String name;

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

public String getName() {
return name;
}

public void run() {
try {
Long duration = (long) (Math.random() * 10);
System.out.println("Executing : " + name);
TimeUnit.SECONDS.sleep(duration);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}答：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){
ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(2);

for (int i = 1; i <= 5; i++) {
Task task = new Task("任务 " + i);
System.out.println("已创建：" + task.getName());

executor.execute(task);
}
executor.shutdown();
}
}class Task implements Runnable {
private String name;

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

public String getName() {
return name;
}

public void run() {
try {
Long duration = (long) (Math.random() * 10);
System.out.println("正在执行：" + name);
TimeUnit.SECONDS.sleep(duration);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

### 回答2：
ThreadPoolExecutor是Java中用来创建和管理线程池的类，可以提高线程的重用性和执行效率。下面是一个详细的代码示例说明如何使用ThreadPoolExecutor。

首先，我们需要导入需要的类：

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

然后，我们可以使用ThreadPoolExecutor类来创建一个线程池，并指定线程池的属性：

int corePoolSize = 5; // 核心线程数
int maxPoolSize = 10; // 最大线程数
long keepAliveTime = 5000; // 线程空闲时间
TimeUnit unit = TimeUnit.MILLISECONDS; // 线程空闲时间的单位

ThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize, maxPoolSize, keepAliveTime, unit,
    new LinkedBlockingQueue<Runnable>()); // 使用LinkedBlockingQueue作为线程队列

接下来，我们可以向线程池中提交任务：

executor.execute(new Runnable() {
    public void run() {
        // 执行任务代码
        System.out.println("Hello World!");
    }
});

或者使用Java 8的Lambda表达式简化代码：

executor.execute(() -> {
    // 执行任务代码
    System.out.println("Hello World!");
});

提交任务后，线程池会自动创建和管理线程，并执行任务。

最后，当使用完线程池后，为了释放资源，需要调用线程池的shutdown()方法来关闭线程池：

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

这就是ThreadPoolExecutor的一个简单示例。通过使用ThreadPoolExecutor，我们可以方便地管理线程池，提高线程的重用性和执行效率。

### 回答3：
ThreadPoolExecutor 是 Java 中用于并发编程的一个线程池实现类。它通过管理和复用线程来提高程序的执行效率。下面给出一个使用 ThreadPoolExecutor 的详细代码示例：

import java.util.concurrent.*;

public class ThreadPoolExecutorExample {

    public static void main(String[] args) {
        // 创建一个线程池，核心线程数为2，最大线程数为4，任务队列容量为10
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                2,  // 核心线程数
                4,  // 最大线程数
                1,  // 线程空闲时间
                TimeUnit.SECONDS,  // 时间单位
                new ArrayBlockingQueue<>(10)  // 任务队列
        );

        // 提交10个任务给线程池执行
        for (int i = 1; i <= 10; i++) {
            final int taskId = i;
            executor.execute(() -> {
                System.out.println("Task " + taskId + " is running on thread " + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);  // 模拟任务执行时间
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Task " + taskId + " is completed");
            });
        }

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

在上面的示例中，我们创建了一个 ThreadPoolExecutor 对象，设置了核心线程数为2，最大线程数为4，线程空闲时间为1秒，任务队列容量为10。

然后我们通过 execute 方法向线程池提交了10个任务，每个任务打印自己的任务编号并模拟一个任务运行时间为1秒的操作。

最后，我们调用 shutdown 方法关闭线程池。

注意，由于线程池的线程数有限，当任务数量超过核心线程数时，超出部分的任务将被放入任务队列中等待执行。当任务队列也满了后，线程池会按照设置的最大线程数创建新的线程来执行任务。