线程池执行器类



java.util.concurrent.ThreadPoolExecutor 是一个 ExecutorService,它使用可能存在的多个池化线程中的一个来执行每个提交的任务,通常使用 Executors 工厂方法进行配置。它还提供各种实用方法来检查当前线程的统计信息并控制它们。

ThreadPoolExecutor 方法

序号 方法及描述
1

protected void afterExecute(Runnable r, Throwable t)

在给定 Runnable 的执行完成时调用的方法。

2

void allowCoreThreadTimeOut(boolean value)

设置策略,该策略控制核心线程是否可能超时并终止(如果在保持活动时间内没有到达任务),并在需要时到达新任务时替换。

3

boolean allowsCoreThreadTimeOut()

如果此池允许核心线程在保持活动时间内没有到达任务时超时并终止,并在需要时到达新任务时替换,则返回 true。

4

boolean awaitTermination(long timeout, TimeUnit unit)

阻止,直到所有任务在关闭请求后完成执行,或者超时发生,或者当前线程被中断,以先发生者为准。

5

protected void beforeExecute(Thread t, Runnable r)

在给定线程中执行给定 Runnable 之前调用的方法。

6

void execute(Runnable command)

在将来某个时间执行给定的任务。

7

protected void finalize()

当不再引用此执行器且它没有线程时,调用 shutdown。

8

int getActiveCount()

返回正在积极执行任务的线程的大致数量。

9

long getCompletedTaskCount()

返回已完成执行的任务的大致总数。

10

int getCorePoolSize()

返回核心线程数。

11

long getKeepAliveTime(TimeUnit unit)

返回线程保持活动时间,这是超过核心池大小的线程在终止之前可能保持空闲的时间量。

12

int getLargestPoolSize()

返回曾经同时在池中的线程的最大数量。

13

int getMaximumPoolSize()

返回允许的最大线程数。

14

int getPoolSize()

返回池中当前的线程数。

15

BlockingQueuegetQueue()

返回此执行器使用的任务队列。

15

RejectedExecutionHandler getRejectedExecutionHandler()

返回当前无法执行任务的处理程序。

16

long getTaskCount()

返回曾经安排执行的任务的大致总数。

17

ThreadFactory getThreadFactory()

返回用于创建新线程的线程工厂。

18

boolean isShutdown()

如果此执行器已关闭,则返回 true。

19

boolean isTerminated()

如果所有任务在关闭后都已完成,则返回 true。

20

boolean isTerminating()

如果此执行器在 shutdown() 或 shutdownNow() 后正在终止过程中但尚未完全终止,则返回 true。

21

int prestartAllCoreThreads()

启动所有核心线程,使它们空闲等待工作。

22

boolean prestartCoreThread()

启动一个核心线程,使它空闲等待工作。

23

void purge()

尝试从工作队列中删除所有已取消的 Future 任务。

24

boolean remove(Runnable task)

如果存在,则从此执行器的内部队列中删除此任务,因此如果它尚未启动,则不会运行它。

25

void setCorePoolSize(int corePoolSize)

设置核心线程数。

26

void setKeepAliveTime(long time, TimeUnit unit)

设置线程在终止之前可能保持空闲的时间限制。

27

void setMaximumPoolSize(int maximumPoolSize)

设置允许的最大线程数。

28

void setRejectedExecutionHandler(RejectedExecutionHandler handler)

设置无法执行任务的新处理程序。

29

void setThreadFactory(ThreadFactory threadFactory)

设置用于创建新线程的线程工厂。

30

void shutdown()

启动有序关闭,其中先前提交的任务将被执行,但不会接受新任务。

31

List<Runnable> shutdownNow()

尝试停止所有正在积极执行的任务,停止等待任务的处理,并返回正在等待执行的任务列表。

32

protected void terminated()

当执行器已终止时调用的方法。

33

String toString()

返回一个字符串,标识此池及其状态,包括运行状态和估计的工作线程和任务计数的指示。

示例

下面的 TestThread 程序演示了在基于线程的环境中使用 ThreadPoolExecutor 接口。

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

public class TestThread {
	
   public static void main(final String[] arguments) throws InterruptedException {
      ThreadPoolExecutor executor = (ThreadPoolExecutor)Executors.newCachedThreadPool();

      //Stats before tasks execution
      System.out.println("Largest executions: "
         + executor.getLargestPoolSize());
      System.out.println("Maximum allowed threads: "
         + executor.getMaximumPoolSize());
      System.out.println("Current threads in pool: "
         + executor.getPoolSize());
      System.out.println("Currently executing threads: "
         + executor.getActiveCount());
      System.out.println("Total number of threads(ever scheduled): "
         + executor.getTaskCount());

      executor.submit(new Task());
      executor.submit(new Task());

      //Stats after tasks execution
      System.out.println("Core threads: " + executor.getCorePoolSize());
      System.out.println("Largest executions: "
         + executor.getLargestPoolSize());
      System.out.println("Maximum allowed threads: "
         + executor.getMaximumPoolSize());
      System.out.println("Current threads in pool: "
         + executor.getPoolSize());
      System.out.println("Currently executing threads: "
         + executor.getActiveCount());
      System.out.println("Total number of threads(ever scheduled): "
         + executor.getTaskCount());

      executor.shutdown();
   }  

   static class Task implements Runnable {

      public void run() {

         try {
            Long duration = (long) (Math.random() * 5);
            System.out.println("Running Task! Thread Name: " +
               Thread.currentThread().getName());
            TimeUnit.SECONDS.sleep(duration);
            System.out.println("Task Completed! Thread Name: " +
               Thread.currentThread().getName());
         } catch (InterruptedException e) {
            e.printStackTrace();
         }
      }
   }
}

这将产生以下结果。

输出

Largest executions: 0
Maximum allowed threads: 2147483647
Current threads in pool: 0
Currently executing threads: 0
Total number of threads(ever scheduled): 0
Core threads: 0
Largest executions: 2
Maximum allowed threads: 2147483647
Current threads in pool: 2
Currently executing threads: 2
Total number of threads(ever scheduled): 2
Running Task! Thread Name: pool-1-thread-2
Running Task! Thread Name: pool-1-thread-1
Task Completed! Thread Name: pool-1-thread-1
Task Completed! Thread Name: pool-1-thread-2
广告