如何使用线程池？

使用线程池可以有效地管理系统中的线程资源，从而提高程序的运行效率和性能，以下是使用线程池的完整使用攻略。

创建线程池

要使用线程池，首先需要创建线程池。线程池可以使用Java提供的ExecutorService类来创建，ExecutorService是一个线程池创建和管理类，可以通过Executors工厂方法来创建不同类型的线程池，包括固定大小线程池、可缓存线程池、单线程线程池等。

创建固定大小线程池

以下是创建一个固定大小为2的线程池的示例代码：

ExecutorService executor = Executors.newFixedThreadPool(2);

创建可缓存线程池

以下是创建一个可缓存的线程池的示例代码：

ExecutorService executor = Executors.newCachedThreadPool();

创建单线程线程池

以下是创建一个单线程的线程池的示例代码：

ExecutorService executor = Executors.newSingleThreadExecutor();

提交任务至线程池

创建线程池后，就可以将需要执行的任务提交给线程池了。可以使用submit()方法将任务提交给线程池。

以下是将一个Runnable任务提交给线程池的示例代码：

executor.submit(new Runnable() {
    public void run() {
        // 执行任务代码
    }
});

以下是将一个Callable任务提交给线程池的示例代码：

Future<String> future = executor.submit(new Callable<String>() {
    public String call() throws Exception {
        // 执行任务代码
        return "任务执行结果";
    }
});

提交任务后，线程池会从线程池中的线程中选择一个可用线程来执行任务。

关闭线程池

使用完线程池后，需要及时关闭线程池，释放资源。线程池可以通过shutdown()方法来关闭。

executor.shutdown();

或者使用shutdownNow()方法来强制关闭线程池。

executor.shutdownNow();

示例说明

下面提供两个示例，分别是使用固定大小线程池和可缓存线程池的例子。

示例一：固定大小线程池

以下是使用固定大小线程池的示例代码，创建了一个含有2个线程的线程池，往线程池中提交3个任务，线程池会依次执行任务1、2，任务3会等待其它任务执行完之后再执行：

public class FixedThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2);
        executor.submit(new Runnable() {
            public void run() {
                System.out.println("任务1开始执行");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("任务1结束执行");
            }
        });
        executor.submit(new Runnable() {
            public void run() {
                System.out.println("任务2开始执行");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("任务2结束执行");
            }
        });
        executor.submit(new Runnable() {
            public void run() {
                System.out.println("任务3开始执行");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("任务3结束执行");
            }
        });
        executor.shutdown();
    }
}

输出结果为：

任务1开始执行
任务2开始执行
任务1结束执行
任务2结束执行
任务3开始执行
任务3结束执行

示例二：可缓存线程池

以下是使用可缓存线程池的示例代码，创建了一个可缓存的线程池，往线程池中提交3个任务，线程池会把每个任务放到一个新的线程中执行：

public class CachedThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newCachedThreadPool();
        executor.submit(new Runnable() {
            public void run() {
                System.out.println("任务1开始执行");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("任务1结束执行");
            }
        });
        executor.submit(new Runnable() {
            public void run() {
                System.out.println("任务2开始执行");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("任务2结束执行");
            }
        });
        executor.submit(new Runnable() {
            public void run() {
                System.out.println("任务3开始执行");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("任务3结束执行");
            }
        });
        executor.shutdown();
    }
}