线程池

一、线程池的分类

1.单线程的线程池

newSingleThreadExecutor 
创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。 
如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。 
此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

2.可缓存的线程池

newCachedThreadPool 
创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，就会回收部分空闲（60秒不执行任务）的线程， 
当任务数增加时，此线程池又可以添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者JVM）能够创建的最大线程数。

3.固定大小的线程池

newFixedThreadPool 
创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。 
线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。

4.大小无限的线程池

newScheduledThreadPool 
创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。

二、示例

1.创建一个线程
public class MyThread extends Thread {
public void run(){
System.out.println(Thread.currentThread().getName()+"正在执行");
}
}
2.测试单线程的线程池
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class TestSingleThreadExecutor {
public static void main(String[] args) {
//创建一个可重用固定线程数的线程池
ExecutorService pool =Executors.newSingleThreadExecutor();
//创建实现了Runnable接口的对象，Thread对象当然也实现了Runnable接口
Thread t1=new MyThread();
Thread t2=new MyThread();
Thread t3=new MyThread();
Thread t4=new MyThread();
Thread t5=new MyThread();
pool.execute(t1);
pool.execute(t2);
pool.execute(t3);
pool.execute(t4);
pool.execute(t5);
//关闭线程池
pool.shutdown();

}
}
运行结果：
pool-1-thread-1正在执行
pool-1-thread-1正在执行
pool-1-thread-1正在执行
pool-1-thread-1正在执行
pool-1-thread-1正在执行
3.测试可缓存的线程池
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class TestCachedThreadPool {
public static void main(String[] args) {
//创建一个可重用固定线程数的线程池
ExecutorService pool =Executors.newCachedThreadPool();
//创建实现了Runnable接口的对象，Thread对象当然也实现了Runnable接口
Thread t1=new MyThread();
Thread t2=new MyThread();
Thread t3=new MyThread();
Thread t4=new MyThread();
Thread t5=new MyThread();
pool.execute(t1);
pool.execute(t2);
pool.execute(t3);
pool.execute(t4);
pool.execute(t5);
//关闭线程池
pool.shutdown();
}
}
运行结果：
pool-1-thread-2正在执行
pool-1-thread-4正在执行
pool-1-thread-3正在执行
pool-1-thread-1正在执行
pool-1-thread-5正在执行
4.测试固定大小的线程池
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class TestFixedThreadPool {
public static void main(String[] args) {
//创建一个可重用固定线程数的线程池
ExecutorService pool =Executors.newFixedThreadPool(2);
//创建实现了Runnable接口的对象，Thread对象当然也实现了Runnable接口
Thread t1=new MyThread();
Thread t2=new MyThread();
Thread t3=new MyThread();
Thread t4=new MyThread();
Thread t5=new MyThread();
pool.execute(t1);
pool.execute(t2);
pool.execute(t3);
pool.execute(t4);
pool.execute(t5);
//关闭线程池
pool.shutdown();
}
}
运行结果：
pool-1-thread-1正在执行
pool-1-thread-2正在执行
pool-1-thread-1正在执行
pool-1-thread-2正在执行
pool-1-thread-1正在执行
5.测试大小无限的线程池
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class TestScheduledThreadPool {
public static void main(String[] args) {
//创建一个可重用固定线程数的线程池
ScheduledThreadPoolExecutor executor=new ScheduledThreadPoolExecutor(1);
executor.scheduleAtFixedRate(new Runnable() {

@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("=======");
}
}, 1000, 5000, TimeUnit.MICROSECONDS);
executor.scheduleAtFixedRate(new Runnable() {

@Override
public void run() {
// TODO Auto-generated method stub
System.out.println(System.nanoTime());
}
}, 1000, 2000, TimeUnit.MICROSECONDS);
//创建实现了Runnable接口的对象，Thread对象当然也实现了Runnable接口

}
}
运行结果：
=======
262318880974161
=======
262318881225509
262318896642130
262318896961303
=======
262318897131718
262318897210371
=======
.....