4 つの Java スレッド プールの使用状況の分析

この記事では、参考のために 4 つの Java スレッド プールの使用法を分析します。具体的な内容は次のとおりです

1. 新しいスレッドの欠点

非同期タスクを実行するときは、やはり新しいスレッドを使用しますか?

new Thread(new Runnable() {
 
  @Override
  public void run() {
    // TODO Auto-generated method stub
    }
  }
).start();

その場合、新しいスレッドの欠点は次のとおりです:

a. 新しいスレッドが新しいオブジェクトを作成するたびに、パフォーマンスが低下します。
b. スレッドを統合管理しないと、新しいスレッドが無制限に作成され、互いに競合し、システム リソースを過剰に占有して、クラッシュや OOM が発生する可能性があります。
c. スケジュールされた実行、定期的な実行、スレッドの中断などの機能が不足しています。

新しいスレッドと比較して、Java が提供する 4 つのスレッド プールの利点は次のとおりです:

a. 既存のスレッドを再利用し、オブジェクトの作成と破棄のコストを削減し、優れたパフォーマンスを実現します。
b. 同時スレッドの最大数を効果的に制御し、システム リソースの使用率を向上させ、過度のリソースの競合と輻輳を回避できます。
c. スケジュール実行、定期実行、シングルスレッド、同時実行制御などの機能を提供します。

2. Java スレッド プール

Java は、Executor を通じて 4 つのスレッド プールを提供します。

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 番目のタスクが実行されると、最初のタスクが完了し、最初のタスクを実行しているスレッドは新しいスレッドを作成せずに再利用されます。毎回。

(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なので、各タスクはインデックス出力後2秒間スリープするため、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 スレッドの応答に影響を与える可能性があります。

スレッド プールの役割:

スレッド プールの役割は、システム内の実行スレッドの数を制限することです。
システム環境に応じて、スレッドの数を自動または手動で設定して、最適な運用効果を実現できます。スレッドの数が少ないとシステム リソースの無駄が発生し、多いとシステムの輻輳や非効率が発生します。スレッド プールを使用してスレッドの数を制御し、他のスレッドは並んで待機します。タスクが実行されると、キュー内の最前部のタスクが取得され、実行が開始されます。キュー内に待機中のプロセスがない場合、スレッド プールのこのリソースは待機中になります。新しいタスクを実行する必要がある場合、スレッド プールに待機中のワーカー スレッドがあれば実行を開始できます。そうでない場合は、待機キューに入ります。

スレッド プールを使用する理由:

1. スレッドの作成と破棄の数を減らし、各ワーカー スレッドを再利用して複数のタスクを実行できます。

2. 過剰なメモリ消費によるサーバーの枯渇を防ぐために、システムの容量に応じてスレッド プール内の作業スレッドの数を調整できます (各スレッドには約 1 MB のメモリが必要であり、より多くのスレッドが開かれると、より多くのメモリが消費され、最終的にはクラッシュします)。

Javaにおけるスレッドプールの最上位インターフェースはExecutorですが、厳密に言えばExecutorはスレッドプールではなく、スレッドを実行するための単なるツールです。実際のスレッド プール インターフェイスは ExecutorService です。

より重要なクラスのいくつか:

ExecutorService: 実際のスレッド プール インターフェイス。

ScheduledExecutorService: Timer/TimerTask と同様に、タスクの繰り返し実行が必要な問題を解決できます。

ThreadPoolExecutor: ExecutorService のデフォルトの実装。

ScheduledThreadPoolExecutor: 定期的なタスク スケジューリングのクラス実装である ThreadPoolExecutor の ScheduledExecutorService インターフェイス実装を継承します。

要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优的，因此在Executors类里面提供了一些静态工厂，生成一些常用的线程池。

1.newSingleThreadExecutor

创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

2.newFixedThreadPool

创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。

3.newCachedThreadPool

创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，

那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。

4.newScheduledThreadPool

创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。

实例代码

一、固定大小的线程池，newFixedThreadPool：

package app.executors;
 
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
 
/**
 * Java线程：线程池
 *
 * @author xiho
 */
public class Test {
  public static void main(String[] args) {
    // 创建一个可重用固定线程数的线程池
    ExecutorService pool = Executors.newFixedThreadPool(2);
    // 创建线程
    Thread t1 = new MyThread();
    Thread t2 = new MyThread();
    Thread t3 = new MyThread();
    Thread t4 = new MyThread();
    Thread t5 = new MyThread();
    // 将线程放入池中进行执行
    pool.execute(t1);
    pool.execute(t2);
    pool.execute(t3);
    pool.execute(t4);
    pool.execute(t5);
    // 关闭线程池
    pool.shutdown();
  }
}
 
class MyThread extends Thread {
  @Override
  public void run() {
    System.out.println(Thread.currentThread().getName() + "正在执行。。。");
  }
}

输出结果：

pool-1-thread-1正在执行。。。
pool-1-thread-3正在执行。。。
pool-1-thread-4正在执行。。。
pool-1-thread-2正在执行。。。
pool-1-thread-5正在执行。。。

改变ExecutorService pool = Executors.newFixedThreadPool(5)中的参数：ExecutorService pool = Executors.newFixedThreadPool(2)，输出结果是：

pool-1-thread-1正在执行。。。
pool-1-thread-1正在执行。。。
pool-1-thread-2正在执行。。。
pool-1-thread-1正在执行。。。
pool-1-thread-2正在执行。。。

从以上结果可以看出，newFixedThreadPool的参数指定了可以运行的线程的最大数目，超过这个数目的线程加进去以后，不会运行。其次，加入线程池的线程属于托管状态，线程的运行不受加入顺序的影响。

二、单任务线程池，newSingleThreadExecutor：

仅仅是把上述代码中的ExecutorService pool = Executors.newFixedThreadPool(2)改为ExecutorService pool = Executors.newSingleThreadExecutor();
输出结果：

pool-1-thread-1正在执行。。。
pool-1-thread-1正在执行。。。
pool-1-thread-1正在执行。。。
pool-1-thread-1正在执行。。。
pool-1-thread-1正在执行。。。

可以看出，每次调用execute方法，其实最后都是调用了thread-1的run方法。

三、可变尺寸的线程池，newCachedThreadPool：

与上面的类似，只是改动下pool的创建方式：ExecutorService pool = Executors.newCachedThreadPool();

输出结果：

pool-1-thread-1正在执行。。。
pool-1-thread-2正在执行。。。
pool-1-thread-4正在执行。。。
pool-1-thread-3正在执行。。。
pool-1-thread-5正在执行。。。

这种方式的特点是：可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。

四、延迟连接池，newScheduledThreadPool：

public class TestScheduledThreadPoolExecutor {
 
  public static void main(String[] args) {
 
    ScheduledThreadPoolExecutor exec = new ScheduledThreadPoolExecutor(1);
 
    exec.scheduleAtFixedRate(new Runnable() {//每隔一段时间就触发异常
 
           @Override
 
           publicvoid run() {
 
              //throw new RuntimeException();
 
              System.out.println("================");
 
           }
 
         }, 1000, 5000, TimeUnit.MILLISECONDS);
 
    exec.scheduleAtFixedRate(new Runnable() {//每隔一段时间打印系统时间，证明两者是互不影响的
 
           @Override
 
           publicvoid run() {
 
              System.out.println(System.nanoTime());
 
           }
 
         }, 1000, 2000, TimeUnit.MILLISECONDS);
 
  }
 
}

输出结果：

================
 
8384644549516
 
8386643829034
 
8388643830710
 
================
 
8390643851383
 
8392643879319
 
8400643939383

   

以上就是本文的全部内容，希望对大家的学习有所帮助。

更多四种Java线程池用法解析相关文章请关注PHP中文网！