Java：多线程，线程池，用Executors静态工厂生成常用线程池
一： newSingleThreadExecutor
创建一个单线程的线程池，以无界队列方式运行。这个线程池只有一个线程在工作（如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。）此线程池能够保证所有任务的执行顺序按照任务的提交顺序执行，同一时段只有一个任务在运行。
此类型线程池特别适合于需要保证执行顺序的场合。
package com.clzhang.sample.thread; import java.util.concurrent.Executors; import java.util.concurrent.ExecutorService; public class ThreadPoolTest1 { static class MyThread implements Runnable { private String name; public MyThread(String name){ this.name = name; }
@Override public void run() { for (int i = 0; i < 2; i++) { // 做点事情 try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } // 如果用Thread.currentThread().getName()方法获取当前线程名称，则不会得到你想到的结果。 System.out.println(name + " said:" + i); } } }
public static void main(String[] args) { // 创建线程池 ExecutorService threadPool = Executors.newSingleThreadExecutor(); // ExecutorService threadPool = Executors.newFixedThreadPool(2); // ExecutorService threadPool = Executors.newCachedThreadPool();
// 向线程池里面扔任务 for (int i = 0; i < 4; i++) { threadPool.execute(new MyThread("Thread" + i)); }
// 关闭线程池 threadPool.shutdown(); } }
void execute(Runnable command):
在未来某个时间执行给定命令。该命令可能在新的线程、已入池的线程或者正调用的线程中执行，这由Executor决定。
void shutdown():
启动一次顺序关闭，执行以前提交的任务，但不接受新任务。如果已经关闭，则调用没有其它作用。
输出：
Thread0 said:0
Thread0 said:1
Thread1 said:0
Thread1 said:1
Thread2 said:0
Thread2 said:1
Thread3 said:0
Thread3 said:1
二：newFixedThreadPool
创建固定大小的线程池，以无界队列方式运行。线程池满且线程都为活动状态的时候如果有新任务提交进来，它们会等待直到有线程可用。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。显式调用shutdown将关闭线程池。
此类型线程池比较符合常用场合。
更改注释以使得上面的示范代码中下述这代码可用：
ExecutorService threadPool = Executors.newFixedThreadPool(2);
输出：
Thread0 said:0
Thread1 said:0
Thread0 said:1
Thread1 said:1
Thread2 said:0
Thread3 said:0
Thread3 said:1
Thread2 said:1
三：newCachedThreadPool
创建一个可缓存的线程池。必要的时候创建新线程来处理请求，也会重用线程池中已经处于可用状态的线程。如果线程池的大小超过了处理任务所需要的线程，那么就会回收部分空闲（60秒不执行任务）的线程；当任务数增加时，此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。
此类型线程池特别适合于耗时短，不需要考虑同步的场合。
更改注释以使得上面的示范代码中下述这代码可用：
ExecutorService threadPool = Executors.newCachedThreadPool();
输出：
Thread0 said:0
Thread2 said:0
Thread3 said:0
Thread1 said:0
Thread0 said:1
Thread2 said:1
Thread3 said:1
Thread1 said:1
四：newScheduledThreadPool
创建可定时运行（初始延时），运行频率（每隔多长时间运行，还是运行成功一次之后再隔多长时间再运行）的线程池。
此类型线程池适合定时以及周期性执行任务的场合。
package com.clzhang.sample.thread; import java.util.*; import java.text.SimpleDateFormat; import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.TimeUnit; public class ThreadPoolTest2 { // 格式化时间 private static SimpleDateFormat MY_SDF = new SimpleDateFormat("mm:ss"); static class MyThread implements Runnable { @Override public void run() { // 做点事情 try { Thread.sleep(1000); System.out.println("[" + MY_SDF.format(new Date()) + "]finished job!"); } catch (InterruptedException e) { e.printStackTrace(); } } } public static void main(String[] args) { // 创建线程池 ScheduledExecutorService schedulePool = Executors.newScheduledThreadPool(1); System.out.println("[" + MY_SDF.format(new Date()) + "]starting...");
// 初始延迟2秒后，只运行一次 schedulePool.schedule(new MyThread(), 2, TimeUnit.SECONDS); // 只运行一次，可以关闭池；下面的两种方式（scheduleAtFixedRate/scheduleWithFixedDelay）则不可以关闭线程池！ schedulePool.shutdown();
// 初始延迟2秒后，每间隔3秒运行一次线程 // schedulePool.scheduleAtFixedRate(new MyThread(), 2, 3, TimeUnit.SECONDS); // 初始延迟2秒后，每运行成功后再等3秒运行一次线程 // schedulePool.scheduleWithFixedDelay(new MyThread(), 2, 3, TimeUnit.SECONDS); } }
三个片段分别运行后的输出：
[04:48]starting...
[04:51]finished job! // 延时2秒后启动线程
-------------------------------------
[06:14]starting...
[06:17]finished job! // 初始延时2秒后启动线程
[06:20]finished job! // 每隔3秒运行一次线程
[06:23]finished job!
......
-------------------------------------
[06:56]starting...
[06:59]finished job! // 初始延时2秒后启动线程
[07:03]finished job! // 上次线程运行成功后再等3秒再次启动
[07:07]finished job!
......
