优质广告供应商

广告是为了更好地支持作者创作

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种类型的线程池执行器。

  1. 固定线程池执行程序——创建一个线程池,该线程池重用固定数量的线程来执行任意数量的任务。如果在所有线程都处于活动状态时提交了其他任务,它们将在队列中等待,直到线程可用。它最适合在现实生活中使用。
    ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(10);
  2. 缓存的线程池执行程序——创建一个线程池,该线程池根据需要创建新线程,但在可用时将重用以前构造的线程。如果任务长时间运行,则不要使用此线程池。如果线程的数量超出了系统所能处理的范围,则会导致系统崩溃。
    ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newCachedThreadPool();
  3. 调度线程池执行程序——创建一个线程池,该线程池可以调度命令在给定延迟后运行或定期执行。
    ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newScheduledThreadPool(10);
  4. 单线程池执行程序-创建单线程来执行所有任务。当您只有一个任务要执行时就可以使用它。
    ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newSingleThreadExecutor();
  5. 工作窃取线程池执行程序-创建一个线程池,该线程池维护足够的线程来支持给定的并行级别。这里的并行级别是指在多处理器机器上,在单点时间内执行给定任务所使用的线程的最大数量。
    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种方法,它们提供不同的功能以重复的方式执行任务。

  1. ScheduledFuture schedule(Runnable command, long delay, TimeUnit unit)——创建并执行在给定延迟之后启用的任务。
  2. ScheduledFuture schedule(Callable callable, long delay, TimeUnit unit)——创建并执行在给定延迟之后启用的ScheduledFuture
  3. ScheduledFuture scheduleAtFixedRate(Runnable command, long initialDelay, long delay, TimeUnit unit)——创建并执行一个周期性动作,该动作在给定的初始延迟之后首先启用,然后在给定的延迟期间启用。如果此任务的任何执行花费的时间超过其周期,则后续执行可能会延迟开始,但不会并发执行。
  4. 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<Runnable> queue;

    public CustomThreadPool(int poolSize) {
        this.poolSize = poolSize;
        queue = new LinkedBlockingQueue<Runnable>();
        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. 总结

  1. ThreadPoolExecutor类有四个不同的构造函数,但是由于它们的复杂性,Java并发API提供了Executors类来构造executor和其他相关对象。尽管我们可以直接使用其构造函数之一创建ThreadPoolExecutor,但建议使用Executors类。
  2. 我们在上面创建的缓存线程池,如果需要执行新任务,它会创建新线程;如果已经完成了正在运行的任务(这些任务现在是可用的)的执行,它会重用现有的线程。但是,缓存的线程池有一个缺点,即新任务的线程总是处于不稳定状态,因此,如果您向这个执行程序发送太多的任务,您可能会使系统过载。这可以通过使用固定线程池来解决,我们将在下一教程中学习这个问题。
  3. ThreadPoolExecutor类和一般的执行器的一个关键方面是,必须显式地结束它。如果不这样做,执行程序将继续执行,程序将不会结束。如果执行程序没有要执行的任务,它将继续等待新任务,并且不会结束执行。Java应用程序在其所有非守护进程线程完成执行之前不会结束,因此,如果不终止执行程序,应用程序将永远不会结束。
  4. 要向执行程序表明想要完成它,可以使用ThreadPoolExecutor类的shutdown()方法。当执行程序完成所有挂起任务的执行时,它就完成了执行。在您调用shutdown()方法之后,如果您尝试将另一个任务发送给执行程序,它将被拒绝,执行程序将抛出RejectedExecutionException异常。
  5. ThreadPoolExecutor类提供了许多方法来获取关于其状态的信息。在示例中,我们使用getPoolSize()getActiveCount()getCompletedTaskCount()方法来获取关于池大小、线程数和执行程序完成的任务数的信息。您还可以使用getLargestPoolSize()方法,该方法每次返回池中已经存在的最大线程数。
  6. ThreadPoolExecutor类还提供了与执行器的终结相关的其他方法。这些方法有:
  • shutdownNow():该方法立即关闭执行程序。它不执行挂起的任务。它返回一个包含所有这些挂起任务的列表。调用此方法时正在运行的任务将继续执行,但该方法不会等待它们的结束。
  • isTerminated():如果您调用了shutdown()shutdownNow()方法,并且执行程序完成了关闭该方法的过程,则该方法返回true。
  • isShutdown():如果调用了executor的shutdown()方法,则该方法返回true。
  • awaitTermination(long timeout,TimeUnitunit):该方法阻塞调用线程,直到执行程序的任务结束或超时发生。TimeUnit类是一个枚举,它具有以下常量:DAYSHOURSMICROSECONDS等。

参考资料

Java Thread Pool – ThreadPoolExecutor Example

优质广告供应商

广告是为了更好地支持作者创作

推荐阅读更多精彩内容