使用Executors和ThreadPoolExecutor2

线程池负责管理工作线程，包含一个等待执行的任务队列。线程池的任务队列是一个Runnable集合，工作线程负责从任务队列中取出并执行Runnable对象。

java.util.concurrent.executors 提供了 java.util.concurrent.executor 接口的一个Java实现，可以创建线程池。下面是一个简单示例：

首先创建一个Runable 类：

WorkerThread.java

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

package com.journaldev.threadpool;

 

public class WorkerThread implementsRunnable {

 

    privateString command;

 

    publicWorkerThread(String s){

        this.command=s;

    }

 

    @Override

    publicvoidrun() {

        System.out.println(Thread.currentThread().getName()+" Start. Command = "+command);

        processCommand();

        System.out.println(Thread.currentThread().getName()+" End.");

    }

 

    privatevoidprocessCommand() {

        try{

            Thread.sleep(5000);

        }catch(InterruptedException e) {

            e.printStackTrace();

        }

    }

 

    @Override

    publicString toString(){

        returnthis.command;

    }

}

下面是一个测试程序，从 Executors 框架中创建固定大小的线程池：

SimpleThreadPool.java

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

package com.journaldev.threadpool;

 

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

 

public class SimpleThreadPool {

 

    publicstaticvoid main(String[] args) {

        ExecutorService executor = Executors.newFixedThreadPool(5);

        for(inti = 0; i <10; i++) {

            Runnable worker =newWorkerThread(""+ i);

            executor.execute(worker);

          }

        executor.shutdown();

        while(!executor.isTerminated()) {

        }

        System.out.println("Finished all threads");

    }

 

}

在上面的程序中，我们创建了包含5个工作线程的固定大小线程池。然后，我们向线程池提交10个任务。由于线程池的大小是5，因此首先会启动5个工作线程，其他任务将进行等待。一旦有任务结束，工作线程会从等待队列中挑选下一个任务并开始执行。

以上程序的输出结果如下：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

pool-1-thread-2Start. Command =1

pool-1-thread-4Start. Command =3

pool-1-thread-1Start. Command =0

pool-1-thread-3Start. Command =2

pool-1-thread-5Start. Command =4

pool-1-thread-4End.

pool-1-thread-5End.

pool-1-thread-1End.

pool-1-thread-3End.

pool-1-thread-3Start. Command =8

pool-1-thread-2End.

pool-1-thread-2Start. Command =9

pool-1-thread-1Start. Command =7

pool-1-thread-5Start. Command =6

pool-1-thread-4Start. Command =5

pool-1-thread-2End.

pool-1-thread-4End.

pool-1-thread-3End.

pool-1-thread-5End.

pool-1-thread-1End.

Finished all threads

从输出结果看，线程池中有五个名为“pool-1-thread-1”…“pool-1-thread-5”的工作线程负责执行提交的任务。

Executors 类使用 ExecutorService  提供了一个 ThreadPoolExecutor 的简单实现，但 ThreadPoolExecutor 提供的功能远不止这些。我们可以指定创建 ThreadPoolExecutor 实例时活跃的线程数，并且可以限制线程池的大小，还可以创建自己的 RejectedExecutionHandler 实现来处理不适合放在工作队列里的任务。

下面是一个 RejectedExecutionHandler 接口的自定义实现：

RejectedExecutionHandlerImpl.java

1

2

3

4

5

6

7

8

9

10

11

12

13

package com.journaldev.threadpool;

 

import java.util.concurrent.RejectedExecutionHandler;

import java.util.concurrent.ThreadPoolExecutor;

 

public class RejectedExecutionHandlerImpl implementsRejectedExecutionHandler {

 

    @Override

    publicvoidrejectedExecution(Runnable r, ThreadPoolExecutor executor) {

        System.out.println(r.toString() +" is rejected");

    }

 

}

ThreadPoolExecutor 提供了一些方法，可以查看执行状态、线程池大小、活动线程数和任务数。所以，我通过一个监视线程在固定间隔输出执行信息。

MyMonitorThread.java

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

package com.journaldev.threadpool;

 

import java.util.concurrent.ThreadPoolExecutor;

 

public class MyMonitorThread implementsRunnable

{

    privateThreadPoolExecutor executor;

 

    privateintseconds;

 

    privatebooleanrun=true;

 

    publicMyMonitorThread(ThreadPoolExecutor executor,intdelay)

    {

        this.executor = executor;

        this.seconds=delay;

    }

 

    publicvoidshutdown(){

        this.run=false;

    }

 

    @Override

    publicvoidrun()

    {

        while(run){

                System.out.println(

                    String.format("[monitor] [%d/%d] Active: %d, Completed: %d, Task: %d, isShutdown: %s, isTerminated: %s",

                        this.executor.getPoolSize(),

                        this.executor.getCorePoolSize(),

                        this.executor.getActiveCount(),

                        this.executor.getCompletedTaskCount(),

                        this.executor.getTaskCount(),

                        this.executor.isShutdown(),

                        this.executor.isTerminated()));

                try{

                    Thread.sleep(seconds*1000);

                }catch(InterruptedException e) {

                    e.printStackTrace();

                }

        }

 

    }

}

下面是使用 ThreadPoolExecutor 的线程池实现示例：

WorkerPool.java

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

package com.journaldev.threadpool;

 

import java.util.concurrent.ArrayBlockingQueue;

import java.util.concurrent.Executors;

import java.util.concurrent.ThreadFactory;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.concurrent.TimeUnit;

 

public class WorkerPool {

 

    publicstaticvoid main(String args[])throws InterruptedException{

        //RejectedExecutionHandler implementation

        RejectedExecutionHandlerImpl rejectionHandler =newRejectedExecutionHandlerImpl();

        //Get the ThreadFactory implementation to use

        ThreadFactory threadFactory = Executors.defaultThreadFactory();

        //creating the ThreadPoolExecutor

        ThreadPoolExecutor executorPool =newThreadPoolExecutor(2,4,10, TimeUnit.SECONDS,newArrayBlockingQueue<Runnable>(2), threadFactory, rejectionHandler);

        //start the monitoring thread

        MyMonitorThread monitor =newMyMonitorThread(executorPool,3);

        Thread monitorThread =newThread(monitor);

        monitorThread.start();

        //submit work to the thread pool

        for(inti=0; i<10; i++){

            executorPool.execute(newWorkerThread("cmd"+i));

        }

 

        Thread.sleep(30000);

        //shut down the pool

        executorPool.shutdown();

        //shut down the monitor thread

        Thread.sleep(5000);

        monitor.shutdown();

 

    }

}

请注意：在初始化 ThreadPoolExecutor 时，初始线程池大小设为2、最大值设为4、工作队列大小设为2。所以，如果当前有4个任务正在运行而此时又有新任务提交，工作队列将只存储2个任务和其他任务将交由RejectedExecutionHandlerImpl 处理。

程序执行的结果如下，确认了上面的结论：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

pool-1-thread-1 Start. Command = cmd0

pool-1-thread-4 Start. Command = cmd5

cmd6 is rejected

pool-1-thread-3 Start. Command = cmd4

pool-1-thread-2 Start. Command = cmd1

cmd7 is rejected

cmd8 is rejected

cmd9 is rejected

[monitor] [0/2] Active: 4, Completed: 0, Task: 6, isShutdown:false, isTerminated:false

[monitor] [4/2] Active: 4, Completed: 0, Task: 6, isShutdown:false, isTerminated:false

pool-1-thread-4 End.

pool-1-thread-1 End.

pool-1-thread-2 End.

pool-1-thread-3 End.

pool-1-thread-1 Start. Command = cmd3

pool-1-thread-4 Start. Command = cmd2

[monitor] [4/2] Active: 2, Completed: 4, Task: 6, isShutdown:false, isTerminated:false

[monitor] [4/2] Active: 2, Completed: 4, Task: 6, isShutdown:false, isTerminated:false

pool-1-thread-1 End.

pool-1-thread-4 End.

[monitor] [4/2] Active: 0, Completed: 6, Task: 6, isShutdown:false, isTerminated:false

[monitor] [2/2] Active: 0, Completed: 6, Task: 6, isShutdown:false, isTerminated:false

[monitor] [2/2] Active: 0, Completed: 6, Task: 6, isShutdown:false, isTerminated:false

[monitor] [2/2] Active: 0, Completed: 6, Task: 6, isShutdown:false, isTerminated:false

[monitor] [2/2] Active: 0, Completed: 6, Task: 6, isShutdown:false, isTerminated:false

[monitor] [2/2] Active: 0, Completed: 6, Task: 6, isShutdown:false, isTerminated:false

[monitor] [0/2] Active: 0, Completed: 6, Task: 6, isShutdown:true, isTerminated:true

[monitor] [0/2] Active: 0, Completed: 6, Task: 6, isShutdown:true, isTerminated:true

请注意活跃线程、已完成线程和任务完成总数的变化。我们可以调用 shutdown() 结束所有已提交任务并终止线程池。

如果希望延迟执行或定期运行任务，那么可以使用 ScheduledThreadPoolExecutor 类。