2. 程式人生 > >簡述Java執行緒池以及使用

簡述Java執行緒池以及使用

阿新 • • 發佈：2018-12-31

建立執行緒的幾種方式

  1. 繼承Thread，重寫run()方法
  2. 實現Runnable介面，實現run()方法
  3. 實現Callable介面，實現Call()方法
  4. 使用執行緒池，並向其提交任務task，其內部自動建立執行緒排程完成。

上述對比：

一般來說，使用第一種和第二種比較普遍，考慮到Java不支援多繼承，通常使用第二種，實現Runnable介面建立執行緒。
然而，假設建立執行緒進行一些複雜的處理，比如需要執行後做出反饋，這時候可以使用實現Callable方式建立執行緒。
About Callable的返回值，可以使用Future或者FutureTask來獲取。

Future

它是一個介面，包含方法：
boolean cancel();
嘗試取消任務，返回ture包括（任務已完成，任務成功取消）
boolean isCancelled();
區別於上一種方法這個更像是一個未完成狀態（完成任務之前的取消），不包括已完成
boolean isDone();
判斷任務是否完成
get();
獲取執行結果，如果任務在執行該方法會阻塞，直到有返回值
get(long timeout,TimeUnitunit);
在有限時間內阻塞得到返回值，否則返回null

FutureTask:

底部實現RunnableFuture介面，而RunnableFuture

繼承了Future和Runnable
所以FutureTask同樣具備上述5個方法。
參考部分原始碼：

/**
     * Creates a {@code FutureTask} that will, upon running, execute the
     * given {@code Callable}.
     *
     * @param  callable the callable task
     * @throws NullPointerException if the callable is null
     */
    public FutureTask
 
(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;       // ensure visibility of callable
    }

    /**
     * Creates a {@code FutureTask} that will, upon running, execute the
     * given {@code Runnable}, and arrange that {@code get} will return the
     * given result on successful completion.
     *
     * @param runnable the runnable task
     * @param result the result to return on successful completion. If
     * you don't need a particular result, consider using
     * constructions of the form:
     * {@code Future<?> f = new FutureTask<Void>(runnable, null)}
     * @throws NullPointerException if the runnable is null
     */
    public FutureTask(Runnable runnable, V result) {
        this.callable = Executors.callable(runnable, result);
        this.state = NEW;       // ensure visibility of callable
    }

可以看到FutureTask可以傳入引數Callable或者Runnable，Result作為構造方法，區別在於：
1. 前者呼叫get()方法獲取的是Callable的call()返回值
2. 後者傳入引數Runnable和Result,如果執行成功，返回Result

Futuretask和Callable實現建立執行緒的Demo

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class CallableThread {
    public static void main(String[] args) {
        ThreadCall tc = new ThreadCall();
        FutureTask<String> result = new FutureTask<>(tc);
        Thread t = new Thread(result);
        t.start();
        while (true) {
            if (result.isDone()) {
                try {
                    System.out.println("Call執行結束:"+result.get());
                    break;
                } catch (InterruptedException | ExecutionException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

class ThreadCall implements Callable<String>{

    @Override
    public String call() throws Exception {
        return "為Java打Call！";
    }

}

執行結果：
Call執行結束:為Java打Call！

執行緒池：

執行緒池可以避免頻繁建立銷燬執行緒，提高效能。常見如資料庫的連線池。
在JUC（java.util.concurrent）中，Java提供了一個工具類Executors用於建立執行緒池[多種型別]，返回一個執行器，再將Runnable或者Callable提交到執行器中[詳見demo]。

執行緒池的幾個型別：
  • newCachedThreadPool(int nThreads)
    接受任務才建立執行緒，如果某個執行緒空閒超過60秒，則會被撤銷。
  • newFixedThreadPool()
    固定執行緒數量的執行緒池，如果執行緒池數量超過nThreads,新任務會放在任務佇列中，如果某個執行緒終止了，另一個執行緒會來取代它。
  • newSingleThreadExecutor()
    只有一個執行緒的執行緒池，依次執行任務
  • newScheduledThreadPool(int corePoolSize)
    指定按照設定的時間週期執行任務，池中執行緒數量根據引數corePoolSize決定，即時有執行緒空閒狀態也不會撤銷。

Demo:

package com.dd.code.ThreadByCallable;

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

public class TestThreadPool {

    public static void main(String[] args) {
        //建立執行緒池（5個執行緒）
        ExecutorService pool = Executors.newFixedThreadPool(5);
        ThreadPoolDemo tpd = new ThreadPoolDemo();

        //為執行緒池分配10個任務
        for (int i = 0; i < 10; i++) {
            pool.submit(tpd);
        }
        //關閉執行緒池(等待任務執行完成才關閉)，區別於shutdownnow立即關閉
        pool.shutdown();
    }

}

class ThreadPoolDemo implements Runnable{

    private int i = 0;

    @Override
    public void run() {
        System.out.println("當前執行緒號："+Thread.currentThread().getName() + "，i = " + i++);
    }

}

執行結果：

當前執行緒號：pool-1-thread-3，i = 2
當前執行緒號：pool-1-thread-5，i = 3
當前執行緒號：pool-1-thread-1，i = 0
當前執行緒號：pool-1-thread-2，i = 1
當前執行緒號：pool-1-thread-3，i = 6
當前執行緒號：pool-1-thread-5，i = 5
當前執行緒號：pool-1-thread-4，i = 4
當前執行緒號：pool-1-thread-3，i = 8
當前執行緒號：pool-1-thread-2，i = 7
當前執行緒號：pool-1-thread-1，i = 9

可以看到，儘管分配10個任務給執行緒池，然而我們初始化5個固定執行緒的執行緒池，所以執行緒池執行的所在程序號不會超過5，而且可以看出在newFixedThreadPool中執行緒的排程是隨機的。

執行緒池多工計算

假如我們要使用執行緒池來執行相應計算，並且取得返回值要如何實現呢？
通常可以使用Future或者FutureTask以結合Callable來實現。

思路：

  1. 建立所需執行緒池，返回執行器[ExecutorService]executor
  2. 使用FutureTask構造方法傳入需要計算的Callable例項化建立FutureTask
  3. 呼叫執行器executor的方法executor.execute(futuretask);
  4. 建立List<FutureTask>將執行的futuretask新增到List中，方便後續取值。

示例：

下面模擬一個計算延遲操作，我們來看看多執行緒和單執行緒執行的效率對比

package com.dd.code.ThreadByCallable;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;
import java.util.concurrent.RejectedExecutionException;

public class MutilThreadTask {
    // 執行緒（內部類）實現Callable介面
    static class MyCallable implements Callable<Long> {
        private long uid;

        public MyCallable(long uid) {
            super();
            this.uid = uid;
        }

        @Override
        public Long call() throws Exception {
            return Work(uid);
        }

        public long Work(long uid) {
            try {
                //模擬查詢操作延遲
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return uid * 2;
        }

    }

    public static void main(String[] args) {
        // 多執行緒累加list
        List<Long> uidList = new ArrayList<Long>();
        for(int i = 0; i < 100; i++){
            uidList.add(10L);
        }

        long t1  = System.currentTimeMillis();
        //使用單執行緒進行計算
        System.out.println("累加結果:" + SumWithOneThread(uidList));
        System.out.println("常規計算時間:"+(System.currentTimeMillis()-t1));

        long t2  = System.currentTimeMillis();
        //建立10個執行緒的執行緒池參與運算
        System.out.println("累加結果:" + SumWithMutilThread(uidList,10));
        System.out.println("執行緒池計算時間:"+(System.currentTimeMillis()-t2));
    }

    static Long SumWithOneThread(List<Long> uidList){
        Long result = 0L;
        for (Long l : uidList) {            
            result += DoubleIt(l);
        }
        return result;
    }

    static Long DoubleIt(Long l){
        try {
            //模擬延遲計算
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return l*2;
    }

    static Long SumWithMutilThread(List<Long> uidList,int THREAD_NUM) {
        // 建立執行緒池
        ExecutorService executor = Executors.newFixedThreadPool(THREAD_NUM);
        // 關於Future和Futuretask可以參考http://blog.csdn.net/zmx729618/article/details/51596414
        // 建立任務列表
        List<FutureTask<Long>> ftlist = new ArrayList<FutureTask<Long>>();
        // MutilThreadTask mt = new MutilThreadTask();
        // 逐個執行任務並且新增到任務列表
        for (Long uid : uidList) {
            /*
             * 例項化內部類MyCallable方法
             * 1.把內部類設為靜態. 
             * 2.通過外部類.例項化內部類，MyCallable callable = mt.new MyCallable(uid);
             */
            MyCallable callable = new MyCallable(uid);
            FutureTask<Long> futuretask = null;
            try {
                futuretask = new FutureTask<Long>(callable);
                executor.execute(futuretask);
            } catch (RejectedExecutionException e) {
                //Re:處理進入執行緒池失敗的情況，也就是說，不僅獲取執行緒資源失敗，並且由於等待佇列已滿，甚至無法進入佇列直接 失敗
                e.printStackTrace();
            }
            ftlist.add(futuretask);
        }
        // 遍歷任務列表，把完成任務取出來獲取資料
        long totalResult = 0L; // 初始化計算資料量
        for (FutureTask<Long> ft : ftlist) {
            Long result = null;
            try {
                result = ft.get();
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
            if (result != null) {
                totalResult += result;
            }
        }
        // 關閉執行器
        executor.shutdown();
        return totalResult;
    }

}

執行結果：

累加結果:2000
常規計算時間:10035
累加結果:2000
執行緒池計算時間:1020

效率對比

果然，使用執行緒池建立多個執行緒計算效率快了許多，但是使用多執行緒就一定快嗎?
我們稍作修改一下方法的引數，只給FutureTask分配5個任務[區別於之前的100個任務]，並且將模擬計算時間修改為1毫秒[區別於之前的100毫秒]，再看看執行結果。

累加結果:100
常規計算時間:6
累加結果:100
執行緒池計算時間:24

發現使用執行緒池的多執行緒計算反而更慢了，可以初步斷定，如果任務量不是很大，計算量不是很複雜的情況下，多執行緒並不是首先，相反執行緒池還需要耗費資源去維護池中的執行緒，所以考慮多執行緒的使用場景，還要權衡一下任務量。

相關推薦

簡述Java執行緒池以及使用

建立執行緒的幾種方式 繼承Thread，重寫run()方法 實現Runnable介面，實現run()方法 實現Callable介面，實現Call()方法 使用執行緒池，並向其提交任務task，其內部自動建立執行緒排程完成。 上述對比： 一般來說，使

java執行緒池以及newCachedThreadPool使用過程中的問題

      為什麼要用執行緒池？原因很簡單，效能好，而且不用自己費心費力的管理執行緒       1、執行緒池基本說明及定義       從JDK 1.5開始，添加了Executors工具類，這個類定義了Executor、ExecutorService、ScheduledE

【小家java】Java執行緒池之---ForkJoinPool執行緒池的使用以及原理

相關閱讀 【小家java】java5新特性（簡述十大新特性） 重要一躍 【小家java】java6新特性（簡述十大新特性） 雞肋升級 【小家java】java7新特性（簡述八大新特性） 不溫不火 【小家java】java8新特性（簡述十大新特性） 飽受讚譽 【小家java】java9

限制Java執行緒池執行執行緒以及等待執行緒數量的策略

對於 java.util.concurrent.Executors 所提供的 FixedThreadPool ，可以保證可以在記憶體中有固定數量的執行緒數執行。但是由於 FixedThreadPool 繫結的是 LinkedBlockingQueue 。佇列的上限沒有限制（預設上限為 Int

JAVA執行緒池--Executors之什麼是執行緒池，為什麼使用執行緒池以及執行緒池的使用

1. 為什麼需要執行緒池？      多執行緒技術主要解決處理器單元內多個執行緒執行的問題，它可以顯著減少處理器單元的閒置時間，增加處理器單元的吞吐能力。              假設一個伺服器完成一項任務所需時間為：T1 建立執行緒時間，T2 線上程中執行任務的時間，T

Java執行緒池的執行原理以及使用詳解

一、 為什麼要使用執行緒池 在一些需要使用執行緒去處理任務的業務場景中，如果每一個任務都建立一個執行緒去處理，任務處理完過後，把這個執行緒銷燬，這樣會產生大量的執行緒建立，銷燬的資源開銷。使用執行緒池能有效的控制這種執行緒的建立和銷燬，而且能夠對建立的執行緒進

Java執行緒池的使用方式，核心執行原理、以及注意事項

Java執行緒池的使用方式，核心執行原理、以及注意事項 執行緒池的緣由 執行緒池的處理流程 執行緒池的使用(ThreadPoolExecutor) 執行緒池的注意事項 執行緒池的緣由 java中為了提高併發度，可以使用多執行緒共同

java執行緒池管理以及分散式

【編者按】多執行緒是程式設計師面試時常常會面對的問題，對多執行緒概念的掌握和理解水平，也常常被用來衡量一個人的程式設計實力。不錯，普通的多執行緒已經不容易了，那麼當多執行緒碰到“大象”又會產生什麼樣的火花？這裡我們為大家分享上海創行科技技術總監嚴瀾的博文——Java執行緒池管理及分散式Hadoop排程框架

java執行緒池配置以及使用

applicationContext-threadpool.xml配置 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/s

java執行緒池詳細入門教程即原始碼解析

##1、執行緒池概念      執行緒池是執行緒的集合，通過執行緒池我們不需要自己建立執行緒，將任務提交給執行緒池即可。為什麼要使用執行緒池，首先，使用執行緒池可以重複利用已有的執行緒繼續執行任務，避免執行緒在建立和銷燬時造成的消耗。其次，由

Java執行緒池ThreadPoolExecutor詳解

  1、執行緒池的工作原理？   執行緒池剛建立時，裡面沒有一個執行緒。任務佇列是作為引數傳進來的。不過，就算佇列裡面有任務，執行緒池也不會馬上執行它們。 當呼叫 execute() 方法新增一個任務時，執行緒池會做如下判斷：

java 執行緒池 ExecutorService相關歸納

public class ExecutorServiceDemo {     public static void main(String[] args) {          // 單執行緒池  &

Java執行緒池Executor框架詳解

Java的執行緒既是工作單元，也是執行機制。從JDK 5開始，把工作單元與執行機制分離開來。工作單元包括Runnable和Callable，而執行機制由Executor框架提供。 Executor框架簡介在HotSpot VM的執行緒模型中，Java執行緒（java.lang.Thread）被一對一對映為本

java執行緒池（有返回值和無返回值）

無返回值： package ThreadPool2; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class test { public stat

揭祕Java執行緒池的真相

執行緒池是指在初始化一個多執行緒應用程式過程中建立一個執行緒集合，然後在需要執行新的任務時重用這些執行緒而不是新建一個執行緒。執行緒池中執行緒的數量通常完全取決於可用記憶體數量和應用程式的需求。然而，增加可用執行緒數量是可能的。執行緒池中的每個執行緒都有被分配一個任務，一旦任務已經完成了，執行緒

Java執行緒池的認識、常用執行緒池的分析

什麼是程式，什麼是程序，什麼是執行緒，他們有什麼區別？   程式是指令和資料的有序集合，其本身並沒有任何執行的含義，是一個靜態的概念。 程序是一個動態的過程，是一個活動的實體。簡單來說，一個應用程式得到執行就可以看作是一個程序。程序可以包含多個同時執行的執行緒。程序也是擁有系統

【小家Java】一次Java執行緒池誤用（newFixedThreadPool）引發的線上血案和總結

相關閱讀 【小家java】java5新特性（簡述十大新特性） 重要一躍 【小家java】java6新特性（簡述十大新特性） 雞肋升級 【小家java】java7新特性（簡述八大新特性） 不溫不火 【小家java】java8新特性（簡述十大新特性） 飽受讚譽 【小家java】java9

總結下java執行緒池的處理策略

執行緒池 任務提交給執行緒池之後的處理策略： 如果當前執行緒池中的執行緒數目<corePoolSize，則每來一個任務，就會建立一個執行緒去執行這個任務； 如果當前執行緒池中的執行緒數目>=corePoolSize，則每來一個任務，會嘗試將其新增到任務快取隊列當中，若

java執行緒池淺析

簡介        執行緒的使用在 java 中佔有極其重要的地位，在 jdk1.4 極其之前的 jdk 版本中，關於執行緒池的使用是極其簡陋的。在 jdk1.5 之後這一情況有了很大的改觀。Jdk1.5 之後加入了java.util.concu

Java執行緒池的疑問

閱讀《Java程式設計思想》第四版，根據書上的程式碼建立執行緒池。 ExecutorService executorService = Executors.newCachedThreadPool(); for (int i = 0; i < count; i++) {