Java通过Executors提供四种线程池
线程池的原理：
http://www.jianshu.com/p/edab547f2710
Java通过Executors提供四种线程池，分别为：
1. newSingleThreadExecutor
创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。
2.newFixedThreadPool
创建固定大小的线程池，可控制线程最大并发数，超出的线程会在队列中等待。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。
3. newCachedThreadPool
创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，
那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。
4.newScheduledThreadPool
创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。
实例
MyThread.java
1 public classMyThread extends Thread { 2 3 @Override 4 public void run() { 5 6 System.out.println(Thread.currentThread().getName() + "正在执行。。。"); 7 8 } 9 10 }
1、newSingleThreadExecutor
1 public classTestSingleThreadExecutor { 2 3 publicstaticvoid main(String[] args) { 4 5 //创建一个可重用固定线程数的线程池 6 7 ExecutorService pool = Executors. newSingleThreadExecutor(); 8 9 //创建实现了Runnable接口对象，Thread对象当然也实现了Runnable接口 10 11 Thread t1 = new MyThread(); 12 13 Thread t2 = new MyThread(); 14 15 Thread t3 = new MyThread(); 16 17 Thread t4 = new MyThread(); 18 19 Thread t5 = new MyThread(); 20 21 //将线程放入池中进行执行 22 23 pool.execute(t1); 24 25 pool.execute(t2); 26 27 pool.execute(t3); 28 29 pool.execute(t4); 30 31 pool.execute(t5); 32 33 //关闭线程池 34 35 pool.shutdown(); 36 37 } 38 39 }
结果：
pool-1-thread-1正在执行。。。 pool-1-thread-1正在执行。。。 pool-1-thread-1正在执行。。。 pool-1-thread-1正在执行。。。 pool-1-thread-1正在执行。。。
2、newFixedThreadPool
1 public class TestFixedThreadPool { 2 3 public static void main(String[] args) { 4 5 //创建一个可重用固定线程数的线程池 6 7 ExecutorService pool = Executors.newFixedThreadPool(2); 8 9 //创建实现了Runnable接口对象，Thread对象当然也实现了Runnable接口 10 11 Thread t1 = new MyThread(); 12 13 Thread t2 = new MyThread(); 14 15 Thread t3 = new MyThread(); 16 17 Thread t4 = new MyThread(); 18 19 Thread t5 = new MyThread(); 20 21 //将线程放入池中进行执行 22 23 pool.execute(t1); 24 25 pool.execute(t2); 26 27 pool.execute(t3); 28 29 pool.execute(t4); 30 31 pool.execute(t5); 32 33 //关闭线程池 34 35 pool.shutdown(); 36 37 } 38 39 }
输出结果：
pool-1-thread-1正在执行。。。 pool-1-thread-2正在执行。。。 pool-1-thread-1正在执行。。。 pool-1-thread-2正在执行。。。 pool-1-thread-1正在执行。。。
3、 newCachedThreadPool
1 public class TestCachedThreadPool { 2 3 public static void main(String[] args) { 4 5 //创建一个可重用固定线程数的线程池 6 7 ExecutorService pool = Executors.newCachedThreadPool(); 8 9 //创建实现了Runnable接口对象，Thread对象当然也实现了Runnable接口 10 11 Thread t1 = new MyThread(); 12 13 Thread t2 = new MyThread(); 14 15 Thread t3 = new MyThread(); 16 17 Thread t4 = new MyThread(); 18 19 Thread t5 = new MyThread(); 20 21 //将线程放入池中进行执行 22 23 pool.execute(t1); 24 25 pool.execute(t2); 26 27 pool.execute(t3); 28 29 pool.execute(t4); 30 31 pool.execute(t5); 32 33 //关闭线程池 34 35 pool.shutdown(); 36 37 } 38 39 }
输出结果：
pool-1-thread-2正在执行。。。 pool-1-thread-4正在执行。。。 pool-1-thread-3正在执行。。。 pool-1-thread-1正在执行。。。 pool-1-thread-5正在执行。。。
4、newScheduledThreadPool
1 public class TestScheduledThreadPoolExecutor { 2 3 public static void main(String[] args) { 4 5 ScheduledThreadPoolExecutor exec = new ScheduledThreadPoolExecutor(1); 6 7 exec.scheduleAtFixedRate(new Runnable() {//每隔一段时间就触发异常 8 9 @Override 10 publicvoid run() { 11 12 //throw new RuntimeException(); 13 14 System.out.println("================"); 15 16 } 17 18 }, 1000, 5000, TimeUnit.MILLISECONDS); 19 20 exec.scheduleAtFixedRate(new Runnable() {//每隔一段时间打印系统时间，证明两者是互不影响的 21 22 @Override 23 publicvoid run() { 24 25 System.out.println(System.nanoTime()); 26 27 } 28 29 }, 1000, 2000, TimeUnit.MILLISECONDS); 30 31 } 32 33 }
输出结果：
================ 8384644549516 8386643829034 8388643830710 ================ 8390643851383 8392643879319 8400643939383
