2. 程式人生 > >Java多執行緒-執行緒池ThreadPoolExecutor構造方法和規則 Java多執行緒-執行緒池ThreadPoolExecutor構造方法和規則

Java多執行緒-執行緒池ThreadPoolExecutor構造方法和規則 Java多執行緒-執行緒池ThreadPoolExecutor構造方法和規則

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

Java多執行緒-執行緒池ThreadPoolExecutor構造方法和規則

2017年05月03日 17:15:37 閱讀數：40542

為什麼用執行緒池

部落格地址 http://blog.csdn.net/qq_25806863

原文地址 http://blog.csdn.net/qq_25806863/article/details/71126867

有時候，系統需要處理非常多的執行時間很短的請求，如果每一個請求都開啟一個新執行緒的話，系統就要不斷的進行執行緒的建立和銷燬，有時花在建立和銷燬執行緒上的時間會比執行緒真正執行的時間還長。而且當執行緒數量太多時，系統不一定能受得了。

使用執行緒池主要為了解決一下幾個問題：

  • 通過重用執行緒池中的執行緒，來減少每個執行緒建立和銷燬的效能開銷。
  • 對執行緒進行一些維護和管理，比如定時開始，週期執行，併發數控制等等。

Executor

Executor是一個介面，跟執行緒池有關的基本都要跟他打交道。下面是常用的ThreadPoolExecutor的關係。

這裡寫圖片描述

Executor介面很簡單，只有一個execute方法。

ExecutorService是Executor的子介面，增加了一些常用的對執行緒的控制方法，之後使用執行緒池主要也是使用這些方法。

AbstractExecutorService是一個抽象類。ThreadPoolExecutor就是實現了這個類。

ThreadPoolExecutor

構造方法

ThreadPoolExecutor是執行緒池的真正實現，他通過構造方法的一系列引數，來構成不同配置的執行緒池。常用的構造方法有下面四個：

這裡寫圖片描述

  • ThreadPoolExecutor(int corePoolSize,
                        int maximumPoolSize,
                        long keepAliveTime,
                        TimeUnit unit,
                        BlockingQueue<Runnable> workQueue)
    • 1
    • 2
    • 3
    • 4
    • 5
  • ThreadPoolExecutor(int corePoolSize,
                        int maximumPoolSize,
                        long keepAliveTime,
                        TimeUnit unit,
                        BlockingQueue<Runnable> workQueue,
                        ThreadFactory threadFactory)
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
  • ThreadPoolExecutor(int corePoolSize,
                        int maximumPoolSize,
                        long keepAliveTime,
                        TimeUnit unit,
                        BlockingQueue<Runnable> workQueue,
                        RejectedExecutionHandler handler)
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
  • ThreadPoolExecutor(int corePoolSize,
                        int maximumPoolSize,
                        long keepAliveTime,
                        TimeUnit unit,
                        BlockingQueue<Runnable> workQueue,
                        ThreadFactory threadFactory,
                        RejectedExecutionHandler handler)
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

構造方法引數說明

  • corePoolSize

    核心執行緒數，預設情況下核心執行緒會一直存活，即使處於閒置狀態也不會受存keepAliveTime限制。除非將allowCoreThreadTimeOut設定為true。

  • maximumPoolSize

    執行緒池所能容納的最大執行緒數。超過這個數的執行緒將被阻塞。當任務佇列為沒有設定大小的LinkedBlockingDeque時，這個值無效。

  • keepAliveTime

    非核心執行緒的閒置超時時間，超過這個時間就會被回收。

  • unit

    指定keepAliveTime的單位，如TimeUnit.SECONDS。當將allowCoreThreadTimeOut設定為true時對corePoolSize生效。

  • workQueue

    執行緒池中的任務佇列.

    常用的有三種佇列，SynchronousQueue,LinkedBlockingDeque,ArrayBlockingQueue。

  • threadFactory

    執行緒工廠，提供建立新執行緒的功能。ThreadFactory是一個介面，只有一個方法

    public interface ThreadFactory {
  Thread newThread(Runnable r);
}
    • 1
    • 2
    • 3

    通過執行緒工廠可以對執行緒的一些屬性進行定製。

    預設的工廠：

    static class DefaultThreadFactory implements ThreadFactory {
  private static final AtomicInteger poolNumber = new AtomicInteger(1);
  private final ThreadGroup group;
  private final AtomicInteger threadNumber = new AtomicInteger(1);
  private final String namePrefix;

  DefaultThreadFactory() {
      SecurityManager var1 = System.getSecurityManager();
      this.group = var1 != null?var1.getThreadGroup():Thread.currentThread().getThreadGroup();
      this.namePrefix = "pool-" + poolNumber.getAndIncrement() + "-thread-";
  }

  public Thread newThread(Runnable var1) {
      Thread var2 = new Thread(this.group, var1, this.namePrefix + this.threadNumber.getAndIncrement(), 0L);
      if(var2.isDaemon()) {
          var2.setDaemon(false);
      }

      if(var2.getPriority() != 5) {
          var2.setPriority(5);
      }

      return var2;
  }
}
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

  • RejectedExecutionHandler

    RejectedExecutionHandler也是一個介面，只有一個方法

    public interface RejectedExecutionHandler {
  void rejectedExecution(Runnable var1, ThreadPoolExecutor var2);
}
    • 1
    • 2
    • 3

    當執行緒池中的資源已經全部使用，新增新執行緒被拒絕時，會呼叫RejectedExecutionHandler的rejectedExecution方法。

執行緒池規則

執行緒池的執行緒執行規則跟任務佇列有很大的關係。

  • 下面都假設任務佇列沒有大小限制：

    1. 如果執行緒數量<=核心執行緒數量，那麼直接啟動一個核心執行緒來執行任務，不會放入佇列中。
    2. 如果執行緒數量>核心執行緒數，但<=最大執行緒數，並且任務佇列是LinkedBlockingDeque的時候，超過核心執行緒數量的任務會放在任務佇列中排隊。
    3. 如果執行緒數量>核心執行緒數，但<=最大執行緒數，並且任務佇列是SynchronousQueue的時候，執行緒池會建立新執行緒執行任務，這些任務也不會被放在任務佇列中。這些執行緒屬於非核心執行緒，在任務完成後，閒置時間達到了超時時間就會被清除。
    4. 如果執行緒數量>核心執行緒數，並且>最大執行緒數，當任務佇列是LinkedBlockingDeque，會將超過核心執行緒的任務放在任務佇列中排隊。也就是當任務佇列是LinkedBlockingDeque並且沒有大小限制時，執行緒池的最大執行緒數設定是無效的，他的執行緒數最多不會超過核心執行緒數。
    5. 如果執行緒數量>核心執行緒數，並且>最大執行緒數，當任務佇列是SynchronousQueue的時候，會因為執行緒池拒絕新增任務而丟擲異常。

  • 任務佇列大小有限時

    1. 當LinkedBlockingDeque塞滿時，新增的任務會直接建立新執行緒來執行，當建立的執行緒數量超過最大執行緒數量時會拋異常。
    2. SynchronousQueue沒有數量限制。因為他根本不保持這些任務，而是直接交給執行緒池去執行。當任務數量超過最大執行緒數時會直接拋異常。

規則驗證

前提

所有的任務都是下面這樣的，睡眠兩秒後列印一行日誌：

Runnable myRunnable = new Runnable() {
    @Override
    public void run() {
        try {
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getName() + " run");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
};
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

所有驗證過程都是下面這樣，先執行三個，再執行三個，8秒後，各看一次資訊

executor.execute(myRunnable);
executor.execute(myRunnable);
executor.execute(myRunnable);
System.out.println("---先開三個---");
System.out.println("核心執行緒數" + executor.getCorePoolSize());
System.out.println("執行緒池數" + executor.getPoolSize());
System.out.println("佇列任務數" + executor.getQueue().size());
executor.execute(myRunnable);
executor.execute(myRunnable);
executor.execute(myRunnable);
System.out.println("---再開三個---");
System.out.println("核心執行緒數" + executor.getCorePoolSize());
System.out.println("執行緒池數" + executor.getPoolSize());
System.out.println("佇列任務數" + executor.getQueue().size());
Thread.sleep(8000);
System.out.println("----8秒之後----");
System.out.println("核心執行緒數" + executor.getCorePoolSize());
System.out.println("執行緒池數" + executor.getPoolSize());
System.out.println("佇列任務數" + executor.getQueue().size());
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

驗證1

  1. 核心執行緒數為6，最大執行緒數為10。超時時間為5秒

    ThreadPoolExecutor executor = new ThreadPoolExecutor(6, 10, 5, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());
    • 1
    ---先開三個---
核心執行緒數6
執行緒池執行緒數3
佇列任務數0
---再開三個---
核心執行緒數6
執行緒池執行緒數6
佇列任務數0
pool-1-thread-1 run
pool-1-thread-6 run
pool-1-thread-5 run
pool-1-thread-3 run
pool-1-thread-4 run
pool-1-thread-2 run
----8秒之後----
核心執行緒數6
執行緒池執行緒數6
佇列任務數0
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

可以看到每個任務都是是直接啟動一個核心執行緒來執行任務，一共建立了6個執行緒，不會放入佇列中。8秒後執行緒池還是6個執行緒，核心執行緒預設情況下不會被回收，不收超時時間限制。

驗證2

  1. 核心執行緒數為3，最大執行緒數為6。超時時間為5秒,佇列是LinkedBlockingDeque

    ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 6, 5, TimeUnit.SECONDS, new LinkedBlockingDeque<Runnable>());
    • 1
    ---先開三個---
核心執行緒數3
執行緒池執行緒數3
佇列任務數0
---再開三個---
核心執行緒數3
執行緒池執行緒數3
佇列任務數3
pool-1-thread-3 run
pool-1-thread-1 run
pool-1-thread-2 run
pool-1-thread-3 run
pool-1-thread-1 run
pool-1-thread-2 run
----8秒之後----
核心執行緒數3
執行緒池執行緒數3
佇列任務數0
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    當任務數超過核心執行緒數時，會將超出的任務放在佇列中，只會建立3個執行緒重複利用。

驗證3

  1. 核心執行緒數為3，最大執行緒數為6。超時時間為5秒,佇列是SynchronousQueue
ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 6, 5, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());
  • 1
---先開三個---
核心執行緒數3
執行緒池執行緒數3
佇列任務數0
---再開三個---
核心執行緒數3
執行緒池執行緒數6
佇列任務數0
pool-1-thread-2 run
pool-1-thread-3 run
pool-1-thread-6 run
pool-1-thread-4 run
pool-1-thread-5 run
pool-1-thread-1 run
----8秒之後----
核心執行緒數3
執行緒池執行緒數3
佇列任務數0
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

當佇列是SynchronousQueue時，超出核心執行緒的任務會建立新的執行緒來執行，看到一共有6個執行緒。但是這些執行緒是費核心執行緒，收超時時間限制，在任務完成後限制超過5秒就會被回收。所以最後看到執行緒池還是隻有三個執行緒。

驗證4

  1. 核心執行緒數是3，最大執行緒數是4，佇列是LinkedBlockingDeque

    ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 4, 5, TimeUnit.SECONDS, new LinkedBlockingDeque<Runnable>());
    • 1
---先開三個---
核心執行緒數3
執行緒池執行緒數3
佇列任務數0
---再開三個---
核心執行緒數3
執行緒池執行緒數3
佇列任務數3
pool-1-thread-3 run
pool-1-thread-1 run
pool-1-thread-2 run
pool-1-thread-3 run
pool-1-thread-1 run
pool-1-thread-2 run
----8秒之後----
核心執行緒數3
執行緒池執行緒數3
佇列任務數0
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

LinkedBlockingDeque根本不受最大執行緒數影響。

但是當LinkedBlockingDeque有大小限制時就會受最大執行緒數影響了

4.1 比如下面，將佇列大小設定為2.

ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 4, 5, TimeUnit.SECONDS, new LinkedBlockingDeque<Runnable>(2));
  • 1
---先開三個---
核心執行緒數3
執行緒池執行緒數3
佇列任務數0
---再開三個---
核心執行緒數3
執行緒池執行緒數4
佇列任務數2
pool-1-thread-2 run
pool-1-thread-1 run
pool-1-thread-4 run
pool-1-thread-3 run
pool-1-thread-1 run
pool-1-thread-2 run
----8秒之後----
核心執行緒數3
執行緒池執行緒數3
佇列任務數0
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

首先為三個任務開啟了三個核心執行緒1，2，3，然後第四個任務和第五個任務加入到佇列中，第六個任務因為佇列滿了，就直接建立一個新執行緒4，這是一共有四個執行緒，沒有超過最大執行緒數。8秒後，非核心執行緒收超時時間影響回收了，因此執行緒池只剩3個執行緒了。

4.2 將佇列大小設定為1

ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 4, 5, TimeUnit.SECONDS, new LinkedBlockingDeque<Runnable>(1));
  • 1
Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task com.sunlinlin.threaddemo.Main$1@677327b6 rejected from java.util.concurrent.ThreadPoolExecutor@14ae5a5[Running, pool size = 4, active threads = 4, queued tasks = 1, completed tasks = 0]
    at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2047)
    at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:823)
    at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1369)
    at com.sunlinlin.threaddemo.Main.main(Main.java:35)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:498)
    at com.intellij.rt.execution.application.AppMain.main(AppMain.java:147)
---先開三個---
核心執行緒數3
執行緒池執行緒數3
佇列任務數0
pool-1-thread-1 run
pool-1-thread-2 run
pool-1-thread-3 run
pool-1-thread-4 run
pool-1-thread-1 run
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

直接出錯在第6個execute方法上。因為核心執行緒是3個，當加入第四個任務的時候，就把第四個放在佇列中。加入第五個任務時，因為佇列滿了，就建立新執行緒執行，建立了執行緒4。當加入第六個執行緒時，也會嘗試建立執行緒，但是因為已經達到了執行緒池最大執行緒數，所以直接拋異常了。

驗證5

  1. 核心執行緒數是3 ，最大執行緒數是4，佇列是SynchronousQueue

    ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 4, 5, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());
    • 1
Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task com.sunlinlin.threaddemo.Main$1@14ae5a5 rejected from java.util.concurrent.ThreadPoolExecutor@7f31245a[Running, pool size = 4, active threads = 4, queued tasks = 0, completed tasks = 0]
    at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2047)
    at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:823)
    at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1369)
    at com.sunlinlin.threaddemo.Main.main(Main.java:34)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:498)
    at com.intellij.rt.execution.application.AppMain.main(AppMain.java:147)
---先開三個---
核心執行緒數3
執行緒池執行緒數3
佇列任務數0
pool-1-thread-2 run
pool-1-thread-3 run
pool-1-thread-4 run
pool-1-thread-1 run
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

這次在新增第五個任務時就報錯了，因為SynchronousQueue各奔不儲存任務，收到一個任務就去建立新執行緒。所以第五個就會拋異常了。


原文:https://blog.csdn.net/qq_25806863/article/details/71126867

為什麼用執行緒池

部落格地址 http://blog.csdn.net/qq_25806863

原文地址 http://blog.csdn.net/qq_25806863/article/details/71126867

有時候，系統需要處理非常多的執行時間很短的請求，如果每一個請求都開啟一個新執行緒的話，系統就要不斷的進行執行緒的建立和銷燬，有時花在建立和銷燬執行緒上的時間會比執行緒真正執行的時間還長。而且當執行緒數量太多時，系統不一定能受得了。

使用執行緒池主要為了解決一下幾個問題：

  • 通過重用執行緒池中的執行緒，來減少每個執行緒建立和銷燬的效能開銷。
  • 對執行緒進行一些維護和管理，比如定時開始，週期執行，併發數控制等等。

Executor

Executor是一個介面，跟執行緒池有關的基本都要跟他打交道。下面是常用的ThreadPoolExecutor的關係。

這裡寫圖片描述

Executor介面很簡單，只有一個execute方法。

ExecutorService是Executor的子介面，增加了一些常用的對執行緒的控制方法，之後使用執行緒池主要也是使用這些方法。

AbstractExecutorService是一個抽象類。ThreadPoolExecutor就是實現了這個類。

ThreadPoolExecutor

構造方法

ThreadPoolExecutor是執行緒池的真正實現，他通過構造方法的一系列引數，來構成不同配置的執行緒池。常用的構造方法有下面四個：

這裡寫圖片描述

  • ThreadPoolExecutor(int corePoolSize,
                        int maximumPoolSize,
                        long keepAliveTime,
                        TimeUnit unit,
                        BlockingQueue<Runnable> workQueue)
    • 1
    • 2
    • 3
    • 4
    • 5
  • ThreadPoolExecutor(int corePoolSize,
                        int maximumPoolSize,
                        long keepAliveTime,
                        TimeUnit unit,
                        BlockingQueue<Runnable> workQueue,
                        ThreadFactory threadFactory)
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
  • ThreadPoolExecutor(int corePoolSize,
                        int maximumPoolSize,
                        long keepAliveTime,
                        TimeUnit unit,
                        BlockingQueue<Runnable> workQueue,
                        RejectedExecutionHandler handler)
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
  • ThreadPoolExecutor(int corePoolSize,
                        int maximumPoolSize,
                        long keepAliveTime,
                        TimeUnit unit,
                        BlockingQueue<Runnable> workQueue,
                        ThreadFactory threadFactory,
                        RejectedExecutionHandler handler)
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

構造方法引數說明

  • corePoolSize

    核心執行緒數，預設情況下核心執行緒會一直存活，即使處於閒置狀態也不會受存keepAliveTime限制。除非將allowCoreThreadTimeOut設定為true。

  • maximumPoolSize

    執行緒池所能容納的最大執行緒數。超過這個數的執行緒將被阻塞。當任務佇列為沒有設定大小的LinkedBlockingDeque時，這個值無效。

  • keepAliveTime

    非核心執行緒的閒置超時時間，超過這個時間就會被回收。

  • unit

    指定keepAliveTime的單位，如TimeUnit.SECONDS。當將allowCoreThreadTimeOut設定為true時對corePoolSize生效。

  • workQueue

    執行緒池中的任務佇列.

    常用的有三種佇列，SynchronousQueue,LinkedBlockingDeque,ArrayBlockingQueue。

  • threadFactory

    執行緒工廠，提供建立新執行緒的功能。ThreadFactory是一個介面，只有一個方法

    public interface ThreadFactory {
  Thread newThread(Runnable r);
}
    • 1
    • 2
    • 3

    通過執行緒工廠可以對執行緒的一些屬性進行定製。

    預設的工廠：

    static class DefaultThreadFactory implements ThreadFactory {
  private static final AtomicInteger poolNumber = new AtomicInteger(1);
  private final ThreadGroup group;
  private final AtomicInteger threadNumber = new AtomicInteger(1);
  private final String namePrefix;

  DefaultThreadFactory() {
      SecurityManager var1 = System.getSecurityManager();
      this.group = var1 != null?var1.getThreadGroup():Thread.currentThread().getThreadGroup();
      this.namePrefix = "pool-" + poolNumber.getAndIncrement() + "-thread-";
  }

  public Thread newThread(Runnable var1) {
      Thread var2 = new Thread(this.group, var1, this.namePrefix + this.threadNumber.getAndIncrement(), 0L);
      if(var2.isDaemon()) {
          var2.setDaemon(false);
      }

      if(var2.getPriority() != 5) {
          var2.setPriority(5);
      }

      return var2;
  }
}
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

  • RejectedExecutionHandler

    RejectedExecutionHandler也是一個介面，只有一個方法

    public interface RejectedExecutionHandler {
  void rejectedExecution(Runnable var1, ThreadPoolExecutor var2);
}
    • 1
    • 2
    • 3

    當執行緒池中的資源已經全部使用，新增新執行緒被拒絕時，會呼叫RejectedExecutionHandler的rejectedExecution方法。

執行緒池規則

執行緒池的執行緒執行規則跟任務佇列有很大的關係。

  • 下面都假設任務佇列沒有大小限制：

    1. 如果執行緒數量<=核心執行緒數量，那麼直接啟動一個核心執行緒來執行任務，不會放入佇列中。
    2. 如果執行緒數量>核心執行緒數，但<=最大執行緒數，並且任務佇列是LinkedBlockingDeque的時候，超過核心執行緒數量的任務會放在任務佇列中排隊。
    3. 如果執行緒數量>核心執行緒數，但<=最大執行緒數，並且任務佇列是SynchronousQueue的時候，執行緒池會建立新執行緒執行任務，這些任務也不會被放在任務佇列中。這些執行緒屬於非核心執行緒，在任務完成後，閒置時間達到了超時時間就會被清除。
    4. 如果執行緒數量>核心執行緒數，並且>最大執行緒數，當任務佇列是LinkedBlockingDeque，會將超過核心執行緒的任務放在任務佇列中排隊。也就是當任務佇列是LinkedBlockingDeque並且沒有大小限制時，執行緒池的最大執行緒數設定是無效的，他的執行緒數最多不會超過核心執行緒數。
    5. 如果執行緒數量>核心執行緒數，並且>最大執行緒數，當任務佇列是SynchronousQueue的時候，會因為執行緒池拒絕新增任務而丟擲異常。

  • 任務佇列大小有限時

    1. 當LinkedBlockingDeque塞滿時，新增的任務會直接建立新執行緒來執行，當建立的執行緒數量超過最大執行緒數量時會拋異常。
    2. SynchronousQueue沒有數量限制。因為他根本不保持這些任務，而是直接交給執行緒池去執行。當任務

相關推薦

Java多執行緒-執行緒池ThreadPoolExecutor構造方法和規則 Java多執行緒-執行緒池ThreadPoolExecutor構造方法和規則

Java多執行緒-執行緒池ThreadPoolExecutor構造方法和規則 2017年05月03日 17:15:37 閱讀數：40542 為什麼用執行緒池 部落格地址 http://blog.csdn.ne

如何用java執行緒池做分批次查詢處理 java執行緒池ThreadPoolExecutor的使用

需求是在一個大資料量的表中按條件查詢出資料後做相應的業務。我是使用的java執行緒池ThreadPoolExecutor，實現分批次去查詢，查詢到資料後，又分多個執行緒去做業務。 執行緒池類為 java.util.concurrent.ThreadPoolExecutor，

Java併發程式設計（6）:Runnable和Thread實現多執行緒的區別(含程式碼)

Java中實現多執行緒有兩種方法：繼承Thread類、實現Runnable介面，在程式開發中只要是多執行緒，肯定永遠以實現Runnable介面為主，因為實現Runnable介面相比繼承Thread類有如下優勢： 1、可以避免由於Java的單繼承特性而帶來的侷限； 2、增強程式的健壯性，程式碼能夠被多個執行

201711671223《Java程式設計》第十一週學習總結 第12章Java多執行緒機制

201711671223《Java程式設計》第十一週學習總結 第12章Java多執行緒機制 作業系統與程序：程式是一段靜態的程式碼，它是應用軟體執行的藍本。程序是程式的一次動態執行過程，它對應了從程式碼載入、執行至執行完畢的一個完整過程，這個過程也是程序本身從產生、發展至消亡的過程。現代作業系統

多執行緒學習（4）：三種實現Java多執行緒的方法：Thread、Callable和Runable 的比較與區別

2018年10月03日 目錄 前言 前言 JVM允許應用程式併發執行多執行緒：最常用的是兩個方法：（1）基礎Thread類，重寫run（）方法；（2）或實現Runnable 介面，實現介面的run（）方法；（3）另外一種方法是：實現callable 介面

基於C++11的執行緒池(threadpool),簡潔且可以帶任意多的引數（轉）

咳咳。C++11 加入了執行緒庫，從此告別了標準庫不支援併發的歷史。然而 c++ 對於多執行緒的支援還是比較低階，稍微高階一點的用法都需要自己去實現，譬如執行緒池、訊號量等。執行緒池(thread pool)這個東西，在面試上多次被問到，一般的回答都是：“管理一個任務佇列，一個執行緒佇列，然後每次取一個任務分

JAVA多執行緒機制第二彈：（程式碼）Ｔｈｒｅａｄ的子類建立執行緒

在Java中，執行緒物件的建立是用Ｔｈｒｅａ類或者它的子類建立。 在編寫Thread類的子類時，需要重寫父類的ｒｕｎ（）方法，其目的是規定執行緒的具體操作，否則執行緒就沒有開始的地方 在這裡，做一個小小總結： 　··線上程的編寫的時候，要重寫父類的ｒｕｎ（）方法，在ｒｕ

執行緒池運用例項——一次錯誤的多執行緒程式設計以及修復過程

寫在前面的話  寫下這篇文章只為了回顧之前在實際工作中犯的一個極其二逼的錯誤，用我的經歷來提示後來者，諸位程式大神，大牛，小牛們看到此文笑笑即可，輕拍輕拍。。。 1 背景 有這麼一個需求，我們的系統（後面簡稱：A系統）需要在後臺執行一個報表匯出任務，在這個任務的執行過程中需要通過CORBA呼

java封裝FFmpeg命令，支援原生ffmpeg全部命令，實現FFmpeg多程序處理與多執行緒輸出控制(開啟、關閉、查詢)，rtsp/rtmp推流、拉流

前言： 之前已經對FFmpeg命令進行了封裝http://blog.csdn.net/eguid_1/article/details/51787646，但是當時沒有考慮到擴充套件性，所以總體設計不是太好，需要改動的地方也比較多，也不支援原生ffmpeg命令，所以本次版本推翻

【Java併發程式設計】之六：Runnable和Thread實現多執行緒的區別（含程式碼）

    Java中實現多執行緒有兩種方法：繼承Thread類、實現Runnable介面，在程式開發中只要是多執行緒，肯定永遠以實現Runnable介面為主，因為實現Runnable介面相比繼承Th

二、JAVA多執行緒：深入理解Thread建構函式（Thread、Runnable、守護執行緒、ThreadGroup）

本章主要介紹了所有與Thread有關的建構函式，執行緒的父子關係（並非繼承關係，而是一種包含關係），Thread和ThreadGroup之間的關係，Thread與虛擬機器棧的關係（學習這部分內容需要讀者有JVM的相關基礎，尤其是對棧記憶體要有深入的理解），最後還介紹了守護執行緒的概念、特點和使用場景

Java多執行緒知識點總結——進階篇（五）之多執行緒下的單例模式

餓漢式 餓漢式多執行緒和單執行緒的程式碼是一樣的，如下： class Single { private static final Single s = new Single(); p

Java中 Thread和Runnable實現多執行緒的區別和聯絡

Java有兩種方式實現多執行緒，第一個是繼承Thread類，第二個是實現Runnable介面。他們之間的聯絡： 1、Thread類實現了Runable介面。 2、都需要重寫裡面Run方法。 他們之間的區別“ 1、實現Runnable的類更具有健壯性，避免了單繼承的侷限。 2

java進階 執行緒池 join用法總結：thread4.join();方法，就表明thread4.join();這個執行緒受到貴客待遇，直到這個執行緒執行完，被插入這個方法的載體執行緒才可以執行。

那個執行緒呼叫join 舉例 thread4.join();方法，就表明thread4.join();這個執行緒受到貴客待遇，直到這個執行緒執行完，被插入這個方法的載體執行緒才可以執行。 package javajinjie.char29.threadpool; pu

Java NIO與IO的區別和比較，NIO與IO執行緒池效能比較

     傳統的socket IO中，需要為每個連線建立一個執行緒，當併發的連線數量非常巨大時，執行緒所佔用的棧記憶體和CPU執行緒切換的開銷將非常巨大。使用NIO，不再需要為每個執行緒建立單獨的執行緒，可以用一個含有限數量執行緒的執行緒池，甚至一個執行緒來為任意數量的連線服務。由於執行緒數量小於連線數量，所

java的泛型和反射，多執行緒

1： java的泛型 2：java的super()在子類中使用時，必須放在第一行，還有對無參函式的呼叫問題。 3： java的反射機制(詳情請參考eclipse的例子) getConstr

Thread和Runnable的區別和聯絡、多次start一個執行緒會怎麼樣

一、Java有兩種方式實現多執行緒，第一個是繼承Thread類，第二個是實現Runnable介面。他們之間的聯絡： 　　  1、Thread類實現了Runable介面。 　　2、都需要重寫裡面Run方法。 二、實現Runnable介面相對於繼承Thread類來說，有如下顯著的好處：

java執行緒和記憶體 java 重排序 java happens-before java 記憶體語義

執行緒之間的通訊機制有兩種：           共享記憶體:在共享記憶體的併發模型裡，執行緒之間共享程式的公共狀態，通過寫-讀記憶體中的公共狀態進行隱式通訊。      

【Python3爬蟲-爬圖片】多執行緒爬取中國國家地理全站美圖，多圖可以提高你的審美哦

宣告：爬蟲為學習使用，請各位同學務必不要對當放網站或i伺服器造成傷害。務必不要寫死迴圈。 - 思路：古鎮——古鎮列表（迴圈獲取古鎮詳情href）——xx古鎮詳情（獲取所有img的src） - 1.  單分類爬： from bs4 import BeautifulSo

網路程式設計和併發之多執行緒程式設計

多執行緒threading 執行緒與程序的區別可以歸納為以下4點： 　　1）地址空間和其它資源（如開啟檔案）：程序間相互獨立，同一程序的各執行緒間共享。某程序內的執行緒在其它程序不可見。 　　2）通訊： 程序間通訊 IPC，執行緒間可以直接讀寫程序資料段（如全域性變數）來進行通訊——