執行緒池

執行緒池：Executor 管理多個非同步任務的執行，而無需程式設計師顯式地管理執行緒的生命週期。這裡的非同步是指多個任務的執行互不干擾，不需要進行同步操作。

主要有四種執行緒池：

快取池

newCachedThreadPool建立一個可緩存執行緒池，如果執行緒池長度超過處理需要，可靈活回收空閒執行緒，若無可回收，則新建執行緒。

下面是它的使用方法：

package com.xzj;

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

 
//   @ author :zjxu     time:2019/1/5
public class Main {
    public static void main(String[] args) {
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            cachedThreadPool.execute(new MyRunnable());
        }
        cachedThreadPool.shutdown();
    }
}

 
class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println(new Date().toString());
        try {
            Thread.sleep(2000);
        } catch (InterruptedException ie) {
            ie.printStackTrace();
        }
    }
}

定長池

newFixedThreadPool可以建立一個定長的執行緒池。定長執行緒池最多隻能同時執行一定個數的執行緒，這個容量在new的時候設定。

下面是一個示例：

package com.xzj;

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

//   @ author :zjxu     time:2019/1/5
public class Main {
    public static void main(String[] args) {
        ExecutorService cachedThreadPool = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 10; i++) {
            cachedThreadPool.execute(new MyRunnable());
        }
        cachedThreadPool.shutdown();
    }
}

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println(new Date().toString());
        try {
            Thread.sleep(2000);
        } catch (InterruptedException ie) {
            ie.printStackTrace();
        }
    }
}

執行結果：

Sat Jan 05 11:59:13 CST 2019
Sat Jan 05 11:59:13 CST 2019
Sat Jan 05 11:59:13 CST 2019
Sat Jan 05 11:59:15 CST 2019
Sat Jan 05 11:59:15 CST 2019
Sat Jan 05 11:59:15 CST 2019
Sat Jan 05 11:59:17 CST 2019
Sat Jan 05 11:59:17 CST 2019
Sat Jan 05 11:59:17 CST 2019
Sat Jan 05 11:59:19 CST 2019

定時池

newScheduledThreadPool建立一個定長執行緒池，支援延遲執行和週期性任務執行。後一種執行方式類似於微控制器的定時器中斷。

1、延遲執行

package com.xzj;

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

//   @ author :zjxu     time:2019/1/5
public class Main {
    public static void main(String[] args) {
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
        System.out.println(new Date().toString());
        scheduledThreadPool.schedule(new MyRunnable(), 3, TimeUnit.SECONDS);
    }
}

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println(new Date().toString());
    }
}

結果：

SatJan0512:15:35CST2019
SatJan0512:15:38CST2019

1、週期執行

scheduleAtFixedRate(x,x,x,x)的第二個引數的意義是初始化延遲，第三個引數的意義是定時間隔延遲。

package com.xzj;

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

//   @ author :zjxu     time:2019/1/5
public class Main {
    public static void main(String[] args) {
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
        System.out.println(new Date().toString());
        scheduledThreadPool.scheduleAtFixedRate(new MyRunnable(), 1, 3, TimeUnit.SECONDS);
        try {
            Thread.sleep(15 * 1000);
        } catch (InterruptedException ie) {
            ie.printStackTrace();
        }
        scheduledThreadPool.shutdown();
    }
}

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println(new Date().toString());
    }
}

執行的結果

1 Sat Jan 05 12:21:07 CST 2019
2 Sat Jan 05 12:21:08 CST 2019
3 Sat Jan 05 12:21:11 CST 2019
4 Sat Jan 05 12:21:14 CST 2019
5 Sat Jan 05 12:21:17 CST 2019
6 Sat Jan 05 12:21:20 CST 2019

 結果中第一二行的原因就是初始化延遲引數形成的。

單執行緒執行緒池

newSingleThreadExecutor建立一個單執行緒化的執行緒池，這個執行緒池當前池中的執行緒死後(或發生異常時)，才能重新啟動新的一個執行緒來替代原來的執行緒繼續執行下去。也就是說按照單執行緒的模式，會按照執行緒新增的順序，一個一個的執行這些執行緒的工作。

package com.xzj;

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

//   @ author :zjxu     time:2019/1/5
public class Main {
    public static void main(String[] args) {
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            final int index = i;
            singleThreadExecutor.execute(new MyRunnable(index));
        }
    }
}

class MyRunnable implements Runnable {
    int i = 0;

    public MyRunnable(int i) {
        this.i = i;
    }

    @Override
    public void run() {
        try {
            System.out.print(i+" ");
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

執行的結果

0 1 2 3 4 5 6 7 8 9 

按照順序，一個一個一次執行。