java线程池实例_Java线程池 - ThreadPoolExecutor示例

为什么需要Java中的线程池?答案通常是，当您在Java中开发一个简单的并发应用程序时，您创建一些Runnable的对象，然后创建相应的线程对象来执行它们。在Java中创建线程是一项昂贵的操作。如果每次执行任务时都开始创建新的线程实例，那么应用程序的性能肯定会下降。

1. 线程池在java中是如何工作的

线程池是预初始化线程的集合。通常集合的大小是固定的，但不是强制的。它有助于使用相同线程执行N个任务。如果线程任务比线程多，那么任务需要在类似队列的结构中等待(FIFO -先进先出)。

当任何线程完成它的执行时，它可以从队列中获取一个新任务并执行它。当所有任务完成时，线程保持活动状态并等待线程池中的更多任务。

Thread Pool

监视程序一直监视队列(通常是阻塞队列BlockingQueue)以执行任何新任务。一旦任务出现，线程就会再次开始接收并执行任务。

2. ThreadPoolExecutor

自Java 5以来，Java并发API提供了一个机制执行器框架。类似的接口为Executor接口、其子接口ExecutorService和实现这两个接口的ThreadPoolExecutor类。

ThreadPoolExecutor分离任务的创建和执行。使用ThreadPoolExecutor，您只需要实现可运行对象并将它们发送到执行程序。它负责它们的执行、实例化和使用必要的线程运行。

不仅如此，使用线程池还提高了性能。当您将任务发送给执行程序时，它会尝试使用一个线程池的线程来执行此任务，以避免线程的连续生成。

3.如何创建ThreadPoolExecutor

我们可以使用java.util.concurrent.Executors接口中的预先构建的方法创建以下5种类型的线程池执行器。

固定线程池执行程序——创建一个线程池，该线程池重用固定数量的线程来执行任意数量的任务。如果在所有线程都处于活动状态时提交了其他任务，它们将在队列中等待，直到线程可用。它最适合在现实生活中使用。

ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(10);

缓存的线程池执行程序——创建一个线程池，该线程池根据需要创建新线程，但在可用时将重用以前构造的线程。如果任务长时间运行，则不要使用此线程池。如果线程的数量超出了系统所能处理的范围，则会导致系统崩溃。

ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newCachedThreadPool();

调度线程池执行程序——创建一个线程池，该线程池可以调度命令在给定延迟后运行或定期执行。

ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newScheduledThreadPool(10);

单线程池执行程序-创建单线程来执行所有任务。当您只有一个任务要执行时就可以使用它。

ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newSingleThreadExecutor();

工作窃取线程池执行程序-创建一个线程池，该线程池维护足够的线程来支持给定的并行级别。这里的并行级别是指在多处理器机器上，在单点时间内执行给定任务所使用的线程的最大数量。

ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newWorkStealingPool(4);

4. ThreadPoolExecutor示例

4.1. 创建任务

让我们创建一个任务，每次都需要随机时间来完成它。

public 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();

}

}

}

4.2. 使用线程池执行器执行任务

给定的程序创建5个任务并提交到executor队列。Executor使用两个线程执行所有任务。

public class ThreadPoolExample {

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();

}

}

Program output:

Created : Task 1

Created : Task 2

Created : Task 3

Created : Task 4

Created : Task 5

Executing : Task 1

Executing : Task 2

Executing : Task 3

Executing : Task 4

Executing : Task 5

5. ScheduledThreadPoolExecutor

当您必须只执行一次惟一任务时，固定线程池或缓存线程池是很好的选择。当您需要执行一个任务，重复N次，或者N次固定次数，或者在固定延迟之后无限次，您应该使用ScheduledThreadPoolExecutor。

ScheduledThreadPoolExecutor提供了4种方法，它们提供不同的功能以重复的方式执行任务。

ScheduledFuture schedule(Runnable command, long delay, TimeUnit unit)——创建并执行在给定延迟之后启用的任务。

ScheduledFuture schedule(Callable callable, long delay, TimeUnit unit)——创建并执行在给定延迟之后启用的ScheduledFuture。

ScheduledFuture scheduleAtFixedRate(Runnable command, long initialDelay, long delay, TimeUnit unit)——创建并执行一个周期性动作，该动作在给定的初始延迟之后首先启用，然后在给定的延迟期间启用。如果此任务的任何执行花费的时间超过其周期，则后续执行可能会延迟开始，但不会并发执行。

ScheduledFuture scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)——创建并执行一个周期性动作，该动作在给定的初始延迟之后首先启用，然后在给定的延迟期间启用。无论一个长时间运行的任务花费多少时间，两次执行之间都会有一个固定的延迟时间间隔。

5.1. ScheduledThreadPoolExecutor示例

public class ScheduledThreadPoolExecutorExample {

public static void main(String[] args) {

ScheduledThreadPoolExecutor executor = (ScheduledThreadPoolExecutor) Executors.newScheduledThreadPool(2);

Task task = new Task("Repeat Task");

System.out.println("Created : " + task.getName());

executor.scheduleWithFixedDelay(task, 2, 2, TimeUnit.SECONDS);

}

}

public 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 + ", Current Seconds : " + new Date());

TimeUnit.SECONDS.sleep(duration);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

输出结果为：

Created : Repeat Task

Executing : Repeat Task, Current Seconds : Mon Mar 04 16:07:05 CST 2019

Executing : Repeat Task, Current Seconds : Mon Mar 04 16:07:13 CST 2019

Executing : Repeat Task, Current Seconds : Mon Mar 04 16:07:17 CST 2019

Executing : Repeat Task, Current Seconds : Mon Mar 04 16:07:22 CST 2019

Executing : Repeat Task, Current Seconds : Mon Mar 04 16:07:27 CST 2019

6. java中的自定义线程池实现

尽管Java通过Executor框架具有非常健壮的线程池功能。如果没有executor，就不应该创建自己的自定义线程池。我强烈反对这种企图。然而，如果您想创建它来学习，下面给出的是Java中的线程池实现。

@SuppressWarnings("unused")

public class CustomThreadPool {

// 线程池大小

private final int poolSize;

// 线程池内部是一个数组

private final WorkerThread[] workers;

// 先进先出队列

private final LinkedBlockingQueue queue;

public CustomThreadPool(int poolSize) {

this.poolSize = poolSize;

queue = new LinkedBlockingQueue();

workers = new WorkerThread[poolSize];

for (int i = 0; i < poolSize; i++) {

workers[i] = new WorkerThread();

workers[i].start();

}

}

public void execute(Runnable task) {

synchronized (queue) {

queue.add(task);

queue.notify();

}

}

private class WorkerThread extends Thread {

public void run() {

Runnable task;

while (true) {

synchronized (queue) {

while (queue.isEmpty()) {

try {

queue.wait();

} catch (InterruptedException e) {

System.out.println("An error occurred while queue is waiting: " + e.getMessage());

}

}

task = queue.poll();

}

try {

task.run();

} catch (RuntimeException e) {

System.out.println("Thread pool is interrupted due to an issue: " + e.getMessage());

}

}

}

}

public void shutdown() {

System.out.println("Shutting down thread pool");

for (int i = 0; i < poolSize; i++) {

workers[i] = null;

}

}

}

我们使用ThreadPoolExecutor执行同样的任务

public class CustomThreadPoolExample {

public static void main(String[] args) {

CustomThreadPool customThreadPool = new CustomThreadPool(2);

for (int i = 1; i <= 5; i++) {

Task task = new Task("Task " + i);

System.out.println("Created : " + task.getName());

customThreadPool.execute(task);

}

}

}

程序输出为：

Created : Task 1

Created : Task 2

Created : Task 3

Created : Task 4

Created : Task 5

Executing : Task 1, Current Seconds : Mon Mar 04 16:24:53 CST 2019

Executing : Task 2, Current Seconds : Mon Mar 04 16:24:53 CST 2019

Executing : Task 3, Current Seconds : Mon Mar 04 16:24:58 CST 2019

Executing : Task 4, Current Seconds : Mon Mar 04 16:25:00 CST 2019

Executing : Task 5, Current Seconds : Mon Mar 04 16:25:01 CST 2019

上面是非常原始的线程池实现，有很多改进。但是，与其完善上面的代码，不如专注于学习Java executor框架。

还要注意，不正确的池或队列处理也会导致死锁或资源抖动。Java社区对Executor框架进行了良好的测试，您当然可以避免这些问题。

7. 总结

ThreadPoolExecutor类有四个不同的构造函数，但是由于它们的复杂性，Java并发API提供了Executors类来构造executor和其他相关对象。尽管我们可以直接使用其构造函数之一创建ThreadPoolExecutor，但建议使用Executors类。

我们在上面创建的缓存线程池，如果需要执行新任务，它会创建新线程；如果已经完成了正在运行的任务(这些任务现在是可用的)的执行，它会重用现有的线程。但是，缓存的线程池有一个缺点，即新任务的线程总是处于不稳定状态，因此，如果您向这个执行程序发送太多的任务，您可能会使系统过载。这可以通过使用固定线程池来解决，我们将在下一教程中学习这个问题。

ThreadPoolExecutor类和一般的执行器的一个关键方面是，必须显式地结束它。如果不这样做，执行程序将继续执行，程序将不会结束。如果执行程序没有要执行的任务，它将继续等待新任务，并且不会结束执行。Java应用程序在其所有非守护进程线程完成执行之前不会结束，因此，如果不终止执行程序，应用程序将永远不会结束。

要向执行程序表明想要完成它，可以使用ThreadPoolExecutor类的shutdown()方法。当执行程序完成所有挂起任务的执行时，它就完成了执行。在您调用shutdown()方法之后，如果您尝试将另一个任务发送给执行程序，它将被拒绝，执行程序将抛出RejectedExecutionException异常。

ThreadPoolExecutor类提供了许多方法来获取关于其状态的信息。在示例中，我们使用getPoolSize()、getActiveCount()和getCompletedTaskCount()方法来获取关于池大小、线程数和执行程序完成的任务数的信息。您还可以使用getLargestPoolSize()方法，该方法每次返回池中已经存在的最大线程数。

ThreadPoolExecutor类还提供了与执行器的终结相关的其他方法。这些方法有:

shutdownNow():该方法立即关闭执行程序。它不执行挂起的任务。它返回一个包含所有这些挂起任务的列表。调用此方法时正在运行的任务将继续执行，但该方法不会等待它们的结束。

isTerminated():如果您调用了shutdown()或shutdownNow()方法，并且执行程序完成了关闭该方法的过程，则该方法返回true。

isShutdown():如果调用了executor的shutdown()方法，则该方法返回true。

awaitTermination(long timeout,TimeUnitunit):该方法阻塞调用线程，直到执行程序的任务结束或超时发生。TimeUnit类是一个枚举，它具有以下常量:DAYS，HOURS，MICROSECONDS等。

参考资料