1.Java併發編程：Callable、Future和FutureTask

創建線程的2種方式，一種是直接繼承Thread，另外一種就是實現Runnable接口。

這2種方式都有一個缺陷就是：在執行完任務之後無法獲取執行結果。

如果需要獲取執行結果，就必須通過共享變量或者使用線程通信的方式來達到效果，這樣使用起來就比較麻煩。

而自從Java 1.5開始，就提供了Callable和Future，通過它們可以在任務執行完畢之後得到任務執行結果。

今天我們就來討論一下Callable、Future和FutureTask三個類的使用方法。

一.Callable與Runnable

先說一下java.lang.Runnable吧，它是一個接口，在它裏面只聲明瞭一個run()方法：

public interface Runnable {
    public abstract void run();
}

由於run()方法返回值爲void類型，所以在執行完任務之後無法返回任何結果。

Callable位於java.util.concurrent包下，它也是一個接口，在它裏面也只聲明瞭一個方法，只不過這個方法叫做call()：

public interface Callable<V> {
    V call() throws Exception;
}

可以看到，這是一個泛型接口，call()函數返回的類型就是傳遞進來的V類型。

那麼怎麼使用Callable呢？一般情況下是配合ExecutorService來使用的，在ExecutorService接口中聲明瞭若干個submit方法的重載版本：

<T> Future<T> submit(Callable<T> task);
<T> Future<T> submit(Runnable task, T result);
Future<?> submit(Runnable task);

第一個submit方法裏面的參數類型就是Callable。

暫時只需要知道Callable一般是和ExecutorService配合來使用的，具體的使用方法講在後面講述。

一般情況下我們使用第一個submit方法和第三個submit方法，第二個submit方法很少使用。

二.Future

　　Future就是對於具體的Runnable或者Callable任務的執行結果進行取消、查詢是否完成、獲取結果。必要時可以通過get方法獲取執行結果，該方法會阻塞直到任務返回結果。

　　Future類位於java.util.concurrent包下，它是一個接口：

public interface Future<V> {
    boolean cancel(boolean mayInterruptIfRunning);
    boolean isCancelled();
    boolean isDone();
    V get() throws InterruptedException, ExecutionException;
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

在Future接口中聲明瞭5個方法，下面依次解釋每個方法的作用：

cancel方法用來取消任務，如果取消任務成功則返回true，如果取消任務失敗則返回false。參數mayInterruptIfRunning表示是否允許取消正在執行卻沒有執行完畢的任務，如果設置true，則表示可以取消正在執行過程中的任務。如果任務已經完成，則無論mayInterruptIfRunning爲true還是false，此方法肯定返回false，即如果取消已經完成的任務會返回false；如果任務正在執行，若mayInterruptIfRunning設置爲true，則返回true，若mayInterruptIfRunning設置爲false，則返回false；如果任務還沒有執行，則無論mayInterruptIfRunning爲true還是false，肯定返回true。
isCancelled方法表示任務是否被取消成功，如果在任務正常完成前被取消成功，則返回 true。
isDone方法表示任務是否已經完成，若任務完成，則返回true；
get()方法用來獲取執行結果，這個方法會產生阻塞，會一直等到任務執行完畢才返回；
get(long timeout, TimeUnit unit)用來獲取執行結果，如果在指定時間內，還沒獲取到結果，就直接返回null。

　　也就是說Future提供了三種功能：

　　1）判斷任務是否完成；

　　2）能夠中斷任務；

　　3）能夠獲取任務執行結果。

　　因爲Future只是一個接口，所以是無法直接用來創建對象使用的，因此就有了下面的FutureTask。

三.FutureTask

我們先來看一下FutureTask的實現：

public class FutureTask<V> implements RunnableFuture<V>

FutureTask類實現了RunnableFuture接口，我們看一下RunnableFuture接口的實現：

public interface RunnableFuture<V> extends Runnable, Future<V> {
    void run();
}

可以看出RunnableFuture繼承了Runnable接口和Future接口，而FutureTask實現了RunnableFuture接口。所以它既可以作爲Runnable被線程執行，又可以作爲Future得到Callable的返回值。

　　FutureTask提供了2個構造器：

public FutureTask(Callable<V> callable) {
}
public FutureTask(Runnable runnable, V result) {
}

事實上，FutureTask是Future接口的一個唯一實現類。

四.使用示例

　　1.使用Callable+Future獲取執行結果

public class Test {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newCachedThreadPool();
        Task task = new Task();
        Future<Integer> result = executor.submit(task);
        executor.shutdown();
         
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }
         
        System.out.println("主線程在執行任務");
         
        try {
            System.out.println("task運行結果"+result.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
         
        System.out.println("所有任務執行完畢");
    }
}
class Task implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        System.out.println("子線程在進行計算");
        Thread.sleep(3000);
        int sum = 0;
        for(int i=0;i<100;i++)
            sum += i;
        return sum;
    }
}

執行結果：

子線程在進行計算
主線程在執行任務
task運行結果4950
所有任務執行完畢

2.使用Callable+FutureTask獲取執行結果

public class Test {
    public static void main(String[] args) {
        //第一種方式
        ExecutorService executor = Executors.newCachedThreadPool();
        Task task = new Task();
        FutureTask<Integer> futureTask = new FutureTask<Integer>(task);
        executor.submit(futureTask);
        executor.shutdown();
         
        //第二種方式，注意這種方式和第一種方式效果是類似的，只不過一個使用的是ExecutorService，一個使用的是Thread
        /*Task task = new Task();
        FutureTask<Integer> futureTask = new FutureTask<Integer>(task);
        Thread thread = new Thread(futureTask);
        thread.start();*/
         
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }
         
        System.out.println("主線程在執行任務");
         
        try {
            System.out.println("task運行結果"+futureTask.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
         
        System.out.println("所有任務執行完畢");
    }
}
class Task implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        System.out.println("子線程在進行計算");
        Thread.sleep(3000);
        int sum = 0;
        for(int i=0;i<100;i++)
            sum += i;
        return sum;
    }
}

如果爲了可取消性而使用 Future 但又不提供可用的結果，則可以聲明 Future<?> 形式類型、並返回 null 作爲底層任務的結果。

2.ExecutorService四種線程池的例子與說明

1、new Thread的弊端

a. 每次new Thread新建對象性能差。

b. 線程缺乏統一管理，可能無限制新建線程，相互之間競爭，及可能佔用過多系統資源導致死機或oom。

c. 缺乏更多功能，如定時執行、定期執行、線程中斷。

相比new Thread，Java Executors提供的四種線程池的好處在於：

a. 重用存在的線程，減少對象創建、消亡的開銷，性能佳。

b. 可有效控制最大併發線程數，提高系統資源的使用率，同時避免過多資源競爭，避免堵塞。

c. 提供定時執行、定期執行、單線程、併發數控制等功能。

2、Java 線程池

Java通過Executors提供四種線程池，分別爲：

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

newFixedThreadPool 創建一個定長線程池，可控制線程最大併發數，超出的線程會在隊列中等待。

newScheduledThreadPool 創建一個定長線程池，支持定時及週期性任務執行。

newSingleThreadExecutor 創建一個單線程化的線程池，它只會用唯一的工作線程來執行任務，保證所有任務按照指定順序(FIFO, LIFO, 優先級)執行。

(1). newCachedThreadPool

創建一個可緩存線程池，如果線程池長度超過處理需要，可靈活回收空閒線程，若無可回收，則新建線程。示例代碼如下：

ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
for (int i = 0; i < 10; i++) {
    final int index = i;
    try {
        Thread.sleep(index * 1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    cachedThreadPool.execute(new Runnable() {

        @Override
        public void run() {
            System.out.println(index);
        }
    });
}

線程池爲無限大，當執行第二個任務時第一個任務已經完成，會複用執行第一個任務的線程，而不用每次新建線程。

(2). newFixedThreadPool

創建一個定長線程池，可控制線程最大併發數，超出的線程會在隊列中等待。示例代碼如下：

ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; i++) {
    final int index = i;
    fixedThreadPool.execute(new Runnable() {


        @Override
        public void run() {
            try {
                System.out.println(index);
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    });
}

因爲線程池大小爲3，每個任務輸出index後sleep 2秒，所以每兩秒打印3個數字。

定長線程池的大小最好根據系統資源進行設置。如Runtime.getRuntime().availableProcessors()。可參考PreloadDataCache。

(3) newScheduledThreadPool

創建一個定長線程池，支持定時及週期性任務執行。延遲執行示例代碼如下：

ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
scheduledThreadPool.schedule(new Runnable() {

    @Override
    public void run() {
        System.out.println("delay 3 seconds");
    }
}, 3, TimeUnit.SECONDS);

表示延遲3秒執行。

定期執行示例代碼如下：

scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
 @Override
	public void run() {
		System.out.println("delay 1 seconds, and excute every 3 seconds");
	}
}, 1, 3, TimeUnit.SECONDS);

表示延遲1秒後每3秒執行一次。

ScheduledExecutorService比Timer更安全，功能更強大，後面會有一篇單獨進行對比。

(4)、newSingleThreadExecutor

創建一個單線程化的線程池，它只會用唯一的工作線程來執行任務，保證所有任務按照指定順序(FIFO, LIFO, 優先級)執行。示例代碼如下：

ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++) {
    final int index = i;
    singleThreadExecutor.execute(new Runnable() {

        @Override
        public void run() {
            try {
                System.out.println(index);
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    });
}

結果依次輸出，相當於順序執行各個任務。

現行大多數GUI程序都是單線程的。Android中單線程可用於數據庫操作，文件操作，應用批量安裝，應用批量刪除等不適合併發但可能IO阻塞性及影響UI線程響應的操作。

Java多線程——FutureTask+ExecutorService

1.Java併發編程：Callable、Future和FutureTask

一.Callable與Runnable

二.Future

三.FutureTask

四.使用示例

2.ExecutorService四種線程池的例子與說明

1、new Thread的弊端

2、Java 線程池

(1). newCachedThreadPool

(2). newFixedThreadPool

(3) newScheduledThreadPool

(4)、newSingleThreadExecutor

Java多線程——FutureTask+ExecutorService

Spring——IOC(控制反轉)、DI(依賴注入)

spring+mybatis useGeneratedKeys返回主鍵

Linux內存信息詳解

mysql實現窗口函數功能

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結