线程池的简单实现
一）、多线程的弊端
1).线程数量过大，耗尽CPU和内存资源。
2).线程的创建和关闭需要花费时间。
3).线程本身也要占用内存空间。
4).大量的线程回收会给GC带来压力，延长GC的停顿时间。
二）、线程池的作用
1).节省多线程在并发时不断创建和销毁线程所带来的额外开销，实现线程的复用。
2).使用线程池后，线程的创建和关闭由线程池维护。
三）、线程池的设计
1).TheadPool: 存储线程，维护线程的创建和关闭的线程池对象
结构：
/*
属性：
* 存放线程的集合： idleThreads, Vector类型
* 线程池的状态： isShoutdown, boolean类型
* 线程池中线程的个数： countThreads, int类型
*
* 方法：
* rePool(): 回收线程，添加至线程池中
* start(): 取出线程池中的线程，执行任务
* shutdown(): 关闭线程
*
* 注： 线程的创建和关闭都是由线程池控制的
*/
2).PreThread: 一个与线程池配合永不退出的线程。
结构：
/**
属性：
* 所属的线程池对象： ThrealPool
* 当前线程的闲置状态： isIdle , boolean类型
* 当前线程的运行状态：isShutdown, Boolean
* 线程任务对象： Runnable, target
*
* 方法：
* 构造方法：public PreThread(Runable target, String name, ThreadPool)
* target: 当前线程池里的线程要执行的任务
* name: 当前线程的名字
* ThreadPool： 当前线程的所属线程池
*
* run(): 调用线程任务
* setTarget(Runable target): 复用线程池的对象，重启设置线程任 务。
* shutdown(): 关闭当前线程
四）、简单线程池的实现
ThreadTool: 线程池
/**
* 线程池对象
* 属性：
* 存放线程的集合： idleThreads, Vector类型
* 线程池的状态： isShoutdown, boolean类型
* 线程池中线程的个数： countThreads, int类型
*
* 方法：
* rePool(): 回收线程，添加至线程池中
* start(): 取出线程池中的线程，执行任务
* shutdown(): 关闭线程
*
* 注： 线程的创建和关闭都是由线程池控制的
*/
public class ThreadPool {
/**
* 单例模式的线程池对象
*/
private static ThreadPool instance;
/**
* 存放空闲线程的集合
*/
private List<PreThread> idleThreads;
/**
* 线程池的状态
*/
private boolean isShutdown;
/**
* 线程池中线程的个数
*/
private int countThreads;
/**
* 私有化线程池构造方法，构建单例模式
*/
private ThreadPool(){
//刚开始，线程池的初始容量为5
idleThreads = new Vector<PreThread>(5);
//线程池里的线程个数为0
countThreads = 0;
}
/**
* 获取线程池实例
*/
public static synchronized ThreadPool getInstance(){
if(instance == null){
instance = new ThreadPool();
}
return instance;
}
/**
* 关闭线程池
*/
public void shutdown(){
//设置线程池的状态
isShutdown = true;
//关闭线程池里的所有线程
for(int i = 0; i < idleThreads.size(); i++){
PreThread preThread = idleThreads.get(i);
preThread.shutdown();
}
}
/**
* 添加空闲线程至线程池
*/
public void rePool(PreThread rePoolingThread){
//判断当前线程池的状态
if(!isShutdown){
//如果线程池未关闭，将线程添加进线程池中
idleThreads.add(rePoolingThread);
}
//若线程已关闭，则关闭当前线程
rePoolingThread.shutdown();
}
/**
* 开启任务线程
*/
public void start(Runnable target){
//判断线程池中是否有线程，有则复用，没有则创建
if(idleThreads.size() > 0){
//有线程则取出线程，重置线程任务
int lastIndex = idleThreads.size() - 1;
//取出线程
PreThread preThread = idleThreads.get(lastIndex);
//将该线程对象从线程池中移除
idleThreads.remove(lastIndex);
//重置线程任务,唤醒等待线程
preThread.setTarget(target);
}
//如若线程池中没有闲置线程，则重新创建线程
else{
PreThread preThread = new PreThread(target,"preThread#"+countThreads,this);
//开启任务线程，并将线程放入线程池
preThread.start();
}
}
}
PreThread: 与线程池配合的永不退出的线程对象
/**
* 与线程池配合的永不退出的线程
* 属性：
* 所属的线程池对象： ThrealPool
* 当前线程的闲置状态： isIdle , boolean类型
* 当前线程的运行状态：isShutdown, Boolean
* 线程任务对象： Runnable, target
*
* 方法：
* 构造方法：public PreThread(Runable target, String name, ThreadPool)
* target: 当前线程池里的线程要执行的任务
* name: 当前线程的名字
* ThreadPool： 当前线程的所属线程池
*
* run(): 调用线程任务
* setTarget(Runable target): 复用线程池的对象，重启设置线程任务
* shutdown(): 关闭当前线程
*/
public class PreThread extends Thread{
/**
* 线程所属线程池
*/
private ThreadPool pool;
/**
* 线程要执行的线程任务
*/
private Runnable target;
/**
* 当前线程的闲置状态
*/
private boolean isIdle = false;
/**
* 当前线程的状态
*/
private boolean isShutdown = false;
/**
* 构造方法，指定线程池，线程任务，线程名字
*/
public PreThread(Runnable target, String name, ThreadPool threadPool){
super(name);
this.target = target;
this.pool = threadPool;
}
/**
* 复用线程池的对象，重置线程任务
*/
public void setTarget(Runnable target){
this.target = target;
//唤醒等待池的线程对象，由waiting状态转为Runable状态，去抢夺系统的资源
synchronized (this) {
//执行notifyAll()后，线程自行抢夺资源，直接进入运行状态，调用run()方法，不用显示的调用start()。
notifyAll();
}
}
/**
* 关闭当前线程
*/
public void shutdown(){
//设置当前的线程为关闭状态，唤醒线程
isShutdown = true;
synchronized (this) {
notifyAll();
}
}
/**
* 执行线程任务的逻辑
*/
@Override
public void run(){
//判断当前的线程是否关闭
//线程未关闭，执行任务线程的业务逻辑
if(!isShutdown){
//设置线程的状态,非闲置状态
isIdle = false;
//执行任务线程
target.run();
//重新设置线程状态为空闲状态
isIdle = true;
//添加当前线程进入线程池
pool.rePool(this);
//执行完任务，线程进入等待状态
try {
/**
* 解释一下，这里为什么要加入代码块：
* 因为wait()/notify()/notifyAll()是配合锁对象使用的。
* 1）.如果线程要调用对象的wait()方法，必须首先获得该对象的监视器 锁，调用wait()之后 当前线程又立即释放掉锁，线程随后进入 WAIT_SET（等待池）中。
* 2).如果线程要调用对象的notify()/notifyAll()方法，也必须先获得 对象的监视器锁调用方法之后，立即释放掉锁然后处于Wait_set的线 程被转移到Entry_set（等锁池）中去竞争锁资源.。The Winner Thread，也就是成功获得了对象的锁的线程，就是对象锁的拥有者，
会进入runnable状态。
*3).由于需要获得锁之后才能够调用wait()/notify()方法，因此必须将 它们放到同步代码块中
*/
synchronized (this) {
//线程进入等待状态，进入到Wait Set中，并释放锁
wait();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
五）、使用线程池和不使用线程池的性能比较
ThreadTask: 线程任务类
/**
* 线程任务类
*/
public class ThreadTask implements Runnable{
private String name;
public ThreadTask(String name){
this.name = name;
}
@Override
public void run() {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
ThreadTest: 测试类
自定义线程池对象:
/**
* 比较实用线程池和不使用线程池的性能
*/
public class ThreadTest {
public static void main(String[] args) {
/**
* 不使用线程池
*/
long start0 = System.currentTimeMillis();
for(int i = 0; i < 1000; i++){
new Thread(new ThreadTask("testThread#"+i)).start();
}
System.out.println("不使用线程池所花费的时间："+(System.currentTimeMillis() - start0));
/**
* 实用线程池
*/
//构造线程池
ThreadPool pool = ThreadPool.getInstance();
long start1 = System.currentTimeMillis();
for(int i = 0; i < 100; i++){
pool.start(new ThreadTask("testThread#"+i));
}
System.out.println("使用线程池所花费的时间："+(System.currentTimeMillis() - start1));
}
}
结果:
不使用线程池所花费的时间：63
使用线程池所花费的时间：7
使用JDK自定义的线程对象：
/**
* 使用JDK自带的线程池：
*
*
*/
public class JDK_ThreadPool {
public static void main(String[] args) {
/**
* 不使用线程池
*/
long start0 = System.currentTimeMillis();
for(int i = 0; i < 1000; i++){
new Thread(new ThreadTask("testThread#"+i)).start();
}
System.out.println("不使用线程池所花费的时间："+(System.currentTimeMillis() - start0));
/**
* 使用线程池
*/
//JDK自带的线程池
//ThreadPool pool = ThreadPool.getInstance();
ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newCachedThreadPool();
long start1 = System.currentTimeMillis();
for(int i = 0; i < 100; i++){
//pool.start(new ThreadTask("testThread#"+i));
executor.execute(new ThreadTask("testThread#"+i));
}
System.out.println("使用线程池所花费的时间："+(System.currentTimeMillis() - start1));
}
}
结果：
不使用线程池所花费的时间：62
使用线程池所花费的时间：7
结论： 不使用线程池的线程需创建1000个线程对象，使用线程池创建的线程对象小于1000个，故使用线程池的性能优于不使用线程池的性能。