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;}
        @Overridepublic 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 {@Overridepublic 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!
......

转载于:https://www.cnblogs.com/nayitian/p/3261678.html