線程池(ThreadPool)建立

線程池建立方式jdk1.5
Java經過Executors（jdk1.5併發包）提供四種線程池，分別爲：

• newCachedThreadPool建立一個可緩存線程池，若是線程池長度超過處理須要，可靈活回收空閒線程，若無可回收，則新建線程。如有空閒線程能夠複用，則優先使用複用的線程，全部線程在當前任務執行完畢後，將返回線程池進行復用。
• newFixedThreadPool 建立一個定長線程池，可控制線程最大併發數，超出的線程會在隊列中等待。
• newScheduledThreadPool 建立一個定長線程池，支持定時及週期性任務執行。
• newSingleThreadExecutor 建立一個單線程化的線程池，它只會用惟一的工做線程來執行任務，保證全部任務按照指定順序(FIFO, LIFO, 優先級)執行。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * newCachedThreadPool建立一個可緩存線程池，若是線程池長度超過處理須要，可靈活回收空閒線程，若無可回收，則新建線程
 * 線程池爲無限大，當執行第二個任務時第一個任務已經完成，會複用執行第一個任務的線程，而不用每次新建線程
 * 此線程池不會對線程池大小作限制，線程池大小徹底依賴於操做系統（或者說JVM）可以建立的最大線程大小
 */
public class CachedThreadPoolDemo {
    public static void main(String[] args){
        ExecutorService threadPool = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            final int temp = i;
            threadPool.execute(()->{
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+",i"+temp);
            });
        }
    }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 建立一個定長線程池，可控制線程最大併發數，超出的線程會在隊列中等待
 */
public class FixedThreadPoolDemo {
    public static void main(String[] args){
        int a = Runtime.getRuntime().availableProcessors();//當前設備的CPU個數
        System.out.println(a);//4
        ExecutorService threadPool = Executors.newFixedThreadPool(a);
        for (int i = 0; i < 10; i++) {
            final int temp = i;
            threadPool.execute(()->{
                //由於線程池大小爲a，每一個任務輸出temp後sleep 2秒，因此每兩秒打印a個數字
                System.out.println(Thread.currentThread().getName()+",i:"+temp);
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
    }
}

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * 建立一個定長線程池，支持定時及週期性任務執行
 */
public class ScheduledThreadPoolDemo {
    public static void main(String[] args){
        ScheduledExecutorService threadPool = Executors.newScheduledThreadPool(5);
        for (int i = 0; i < 10; i++) {
            final int temp = i;
            threadPool.schedule(() -> {
                System.out.println("i:"+temp);
            },3, TimeUnit.SECONDS); //延遲3秒執行
        }
    }
}

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * - scheduleAtFixedRate (Runnable command,long initialDelay,long period,TimeUnit unit)
 * 以上一個任務的開始時間爲起點，以後的period時間，調度下一次任務
 * 建立一個週期性任務。任務開始於給定的初始延時。後續的任務按照給定的週期進行：後續第一個任務將會在
 * initialDelay+period時執行，後續第二個任務將在initialDelay+2*period時執行，依此類推
 */
public class ScheduledThreadPoolDemo2 {
    public static void main(String[] args){
        ScheduledExecutorService service = Executors.newScheduledThreadPool(10);
        service.scheduleAtFixedRate(()->{
            try {
                //Thread.sleep(1000);//執行時間爲一秒
                Thread.sleep(8000);//執行時間爲8秒
                System.out.println(System.currentTimeMillis()/1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },0,2, TimeUnit.SECONDS);//週期爲2秒
    }
    //1567587961
    //1567587963
    //1567587965
    //1567587967
    //1567587969
    //時間間隔爲2秒

    //1567588064
    //1567588072
    //1567588080
    //時間間隔爲8秒
    //週期若是過短，那麼任務就會在上一個任務結束後，當即被調用。
}

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * - scheduleWithFixedDelay(Runnable command,long initialDelay,long delay, TimeUnit unit)
 * 在上一個任務結束後，再通過delay時間進行任務調度
 * 建立並執行一個週期性任務。任務開始於初始延時時間。後續任務將會按照給定的延時進行，即上一個任務的結束
 * 時間到下一個任務的開始時間的時間差。
 */
public class ScheduledThreadPoolDemo3 {
    public static void main(String[] args){
        ScheduledExecutorService service = Executors.newScheduledThreadPool(10);
        service.scheduleWithFixedDelay(()->{
            try {
                //Thread.sleep(1000);//執行時間爲一秒
                Thread.sleep(8000);//執行時間爲8秒
                System.out.println(System.currentTimeMillis()/1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },0,2, TimeUnit.SECONDS);//週期爲2秒
    }
    //1567588363
    //1567588366
    //1567588369
    //1567588372
    //1567588375
    //1567588378
    //時間間隔爲3秒

    //1567588623
    //1567588633
    //1567588643
    //1567588653
    //時間間隔爲10秒
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 建立一個單線程化的線程池，它只會用惟一的工做線程來執行任務，保證全部任務按照指定順序(FIFO, LIFO, 優先級)執行
 * 結果依次輸出，至關於順序執行各個任務
 */
public class SingleThreadExecutorDemo {
    public static void main(String[] args){
        ExecutorService threadExecutor = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            final int index = i;
            threadExecutor.execute(()->{
                System.out.println("index:"+index);
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
    }
}

• newSingleThreadScheduledExecutor()方法： 該方法返回一個ScheduledExecutorService對象，線程池大小爲1，ScheduledExecutorService接口在ExecutorService接口 之上擴展了在給定時間執行某任務的功能，如在某個固定的延時以後執行，或者週期性執行某個任務。