Java线程和多线程（十二）——线程池基础
2016-10-30 11:12
471 查看
Java 线程池管理多个工作线程，其中包含了一个队列，包含着所有等待被执行的任务。开发者可以通过使用
线程池是Java中多线程的一个重要概念，因为通过
其中包含了一些基本的关闭，执行等功能
上面的代码是一个简单的实现了
上面个程序中的
下面是上面程序的输出内容：
其中输出的内容也说明了在线程池中有5个线程，名字从
时指定线程池的大小，也可以定制
下面是我们的自定义的
下面是使用
需要注意的是，当我们在创建
可以观察线程池在各个状态，如：活跃状态数，任务的完成数等等信息的变化。我们通过调用
如果开发者希望来延迟执行一个任务，或者定期执行一个任务的话，开发者可以使用
ThreadPoolExecutor来在Java中创建线程池。
线程池是Java中多线程的一个重要概念，因为通过
Thread模型来控制多线程是非常麻烦以及易错的一个过程。过多的释放线程会造成线程调度的变慢以及过度的消耗内存。而频繁的创建线程，也没有很好的复用线程，所以有了线程池的概念。Java中的线程池就是
ExecutorService。
其中包含了一些基本的关闭，执行等功能
ExecutorService举例
java.util.concurrent.Executors提供了
java.util.concurrent.Executor接口的实现，并且用来提供线程池服务。参考如下代码：
package com.sapphire.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;
}
}上面的代码是一个简单的实现了
Runnable的
WorkThread。下面展示的是线程池代码，通过
Executors框架创建的固定线程数的线程池。
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");
}
}上面个程序中的
ExecutorService executor就是一个线程池，其调用的函数
Executors.newFixedThreadPool(int size)函数来生成固定的线程数的一个线程池。在程序中，我们通过一个for循环提交了10个任务，因为我们配置了线程池的大小，所以其中的线程数最大始终是5不会出现无限创建线程的那种情况，当同时有其他的任务提交到线程池的时候，线程池会持续的等待，直到有一个任务完成，那么另一个任务就会从等待队列里面出来，进入执行队列来执行。
下面是上面程序的输出内容：
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
其中输出的内容也说明了在线程池中有5个线程，名字从
pool-1-thread-1到
pool-1-thread-5,由叫这5个名字的线程负责执行提交到线程池的任务。
ThreadPoolExecutor举例
Executors类通过
ThreadPoolExecutor提供了
ExecutorService的简单实现，但是，
ThreadPoolExecutor提供的特性更多。我们可以在创建
ThreadPoolExecutor
时指定线程池的大小，也可以定制
RejectedExecutionHandler的实现来处理无法加入工作队列的任务。
下面是我们的自定义的
RejectedExecutionHandler:
package com.sapphire.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会提供一些方法，令开发者可以知道目前线程池的状态，比如，线程池大小，活跃的线程数，任务队列长度等信息。所以，下面我写了一个监控线程来定期展示线程池的状态信息。
package com.sapphire.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();
}
}
}
}下面是使用
ThreadPoolExecutor的实现方案。
package com.sapphire.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个运行的任务的时候，再提交更多任务的时候，则至多只能提交两个处于等待状态的任务。如果再提交更多的话，则会由
RejectedExecutionHandlerImpl来处理。
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线程和多线程（十二）——线程池基础
- JAVA基础学习(十二)--多线程一线程之间的通信
- 【Java基础】Java多线程之线程组和线程池
- Java基础多线程之后台守护线程，setDaemon(true)
- java基础之：多线程实现/启动/状态+同步+线程池
- Java基础多线程之join抢夺CPU执行权直到该线程结束。
- Java基础学习__多线程（线程间通信--生产者消费者JDK5.0升级版）
- Java基础学习5_多线程（线程间通信--等待唤醒机制）
- java多线程并发（二）（线程基础）
- Java基础_线程_多线程_生产者消费者问题
- 黑马程序员-----java基础十二（java之多线程）
- Java基础_线程_多线程
- Java多线程编程基础之线程对象
- 黑马程序员--JAVA基础复习之多线程（二）线程安全与解决方法
- java基础——多线程（线程的同步互斥与通信）
- Java基础多线程之线程中止示例：
- Java多线程编程基础之线程对象
- java基础学习__多线程（停止线程，守护线程，join方法）
- 多线程并发库高级应用 之 java5中的线程并发库--线程池、Callable&Future
- 黑马程序员--JAVA基础复习之多线程（三）线程间通信 生产者消费者