一个线程池管理工作线程池,它包含一个队列,使任务等待被执行。一个线程池管理的可运行线程和辅助线程集合执行运行队列中的.
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
implements
Runnable {
private
String command;
public
WorkerThread(String s){
this
.command=s;
}
@Override
public
void
run() {
System.out.println(Thread.currentThread().getName()+
" Start. Command = "
+command);
processCommand();
System.out.println(Thread.currentThread().getName()+
" End."
);
}
private
void
processCommand() {
try
{
Thread.sleep(
5000
);
}
catch
(InterruptedException e) {
e.printStackTrace();
}
}
@Override
public
String toString(){
return
this
.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 {
public
static
void
main(String[] args) {
ExecutorService executor = Executors.newFixedThreadPool(
5
);
for
(
int
i =
0
; i <
10
; i++) {
Runnable worker =
new
WorkerThread(
""
+ 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-
2
Start. Command =
1
pool-
1
-thread-
4
Start. Command =
3
pool-
1
-thread-
1
Start. Command =
0
pool-
1
-thread-
3
Start. Command =
2
pool-
1
-thread-
5
Start. Command =
4
pool-
1
-thread-
4
End.
pool-
1
-thread-
5
End.
pool-
1
-thread-
1
End.
pool-
1
-thread-
3
End.
pool-
1
-thread-
3
Start. Command =
8
pool-
1
-thread-
2
End.
pool-
1
-thread-
2
Start. Command =
9
pool-
1
-thread-
1
Start. Command =
7
pool-
1
-thread-
5
Start. Command =
6
pool-
1
-thread-
4
Start. Command =
5
pool-
1
-thread-
2
End.
pool-
1
-thread-
4
End.
pool-
1
-thread-
3
End.
pool-
1
-thread-
5
End.
pool-
1
-thread-
1
End.
Finished all threads
|
从输出结果看,池中有线程名从“pool-1-thread-1”到“pool-1-thread-5”来进行执行以上提交的任务。
Executors 提供了使用的 ThreadPoolExecutor 的ExecutorService简单的实现 ,但的 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
implements
RejectedExecutionHandler {
@Override
public
void
rejectedExecution(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
implements
Runnable
{
private
ThreadPoolExecutor executor;
private
int
seconds;
private
boolean
run=
true
;
public
MyMonitorThread(ThreadPoolExecutor executor,
int
delay)
{
this
.executor = executor;
this
.seconds=delay;
}
public
void
shutdown(){
this
.run=
false
;
}
@Override
public
void
run()
{
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();
}
}
}
}
|
这里是实现线程池的例子使用线程池:
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 {
public
static
void
main(String args[])
throws
InterruptedException{
//RejectedExecutionHandler implementation
RejectedExecutionHandlerImpl rejectionHandler =
new
RejectedExecutionHandlerImpl();
//Get the ThreadFactory implementation to use
ThreadFactory threadFactory = Executors.defaultThreadFactory();
//creating the ThreadPoolExecutor
ThreadPoolExecutor executorPool =
new
ThreadPoolExecutor(
2
,
4
,
10
, TimeUnit.SECONDS,
new
ArrayBlockingQueue<Runnable>(
2
), threadFactory, rejectionHandler);
//start the monitoring thread
MyMonitorThread monitor =
new
MyMonitorThread(executorPool,
3
);
Thread monitorThread =
new
Thread(monitor);
monitorThread.start();
//submit work to the thread pool
for
(
int
i=
0
; i<
10
; i++){
executorPool.execute(
new
WorkerThread(
"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 类。了解更多关于他们在Java Schedule Thread Pool Executor.