ホームページ > 記事 > Java > Javaスレッドプールを作成する方法

Javaスレッドプールを作成する方法

PHPz転載: 2023-05-16 08:43:123313ブラウズ

スレッドプールの利点

スレッドの再利用を実現し、スレッドの再作成や破棄を回避できます。スレッドの作成と破棄は、CPU にとって非常に負荷がかかります。
作成できるスレッドの最大数を制限し、マシンのパフォーマンスに応じてスレッドプールのパラメーターを動的に調整して、アプリケーションのパフォーマンスを向上させることができます。
スケジュール実行や同時実行制御などの機能を提供します。
#スレッドの統合管理。

スレッドプールを作成する 5 つの方法

1: キャッシュスレッドプール (非推奨)

2: 固定容量のスレッドプール (非推奨)

3: シングルスレッドプール (推奨されません)

4: スケジュールされたタスクのスレッドプール (推奨されません)

5: ThreadPoolExecutor 構築メソッド (開発された) を使用してスレッドプールを作成しますAlibaba のマニュアルを強くお勧めします)

スレッドプールを作成する最初の 4 つの方法はすべて、Executor の静的メソッドを通じて作成されます。

キャッシュスレッドプール CachedThreadPool

	ExecutorService executorService = Executors.newCachedThreadPool();

        for (int i = 0; i < 10; i++) {
            final int finalI = i;
            executorService.execute(new Runnable() {
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"<thread->run>"+ finalI);
                }
            });
        }

キャッシュスレッドプールが推奨されないのはなぜですか?

ソースコード分析

public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, 2147483647, 60L, TimeUnit.SECONDS, new SynchronousQueue());
    }

 public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, Executors.defaultThreadFactory(), defaultHandler);
    }

上記の 2 つのコードスニペットから、CachedThreadPool の MaximumPoolSize が整数の最大値 2147483647 であることがわかります。これは、無制限のスレッド作成とスレッドの作成に相当します。メモリが必要です。はい、これによりメモリオーバーフローが発生します。通常のマシンでは、これほど大量のスレッドを作成するためにそれほど大きなメモリを使用することはありません。

固定容量スレッドプールFixedThreadPool

newFixedThreadPool(int num)、num は指定する固定スレッドの数です

	ExecutorService executorService = Executors.newFixedThreadPool(5);

      for (int i = 0; i < 10; i++) {
          final int finalI = i;
          executorService.execute(new Runnable() {
              public void run() {
                  System.out.println(Thread.currentThread().getName()+"<thread->run>"+ finalI);
              }
          });
      }

出力:

pool-1-thread-575b3c38ff368dcafe01d2cfbd3d86ea2run>4
pool-1-thread-475b3c38ff368dcafe01d2cfbd3d86ea2run>3
pool-1-thread-575b3c38ff368dcafe01d2cfbd3d86ea2 run> 5
pool-1-thread-375b3c38ff368dcafe01d2cfbd3d86ea2run>2
pool-1-thread-375b3c38ff368dcafe01d2cfbd3d86ea2run>8
pool-1-thread-3b515038e79715e2588b433552eb233c0run>9
pool-1-thread-275b3c38ff368dcafe01d2cfbd3d86ea2run>1
pool-1-thread-175b3c38ff368dcafe01d2cfbd3d86ea2run>0
pool-1- thread- 575b3c38ff368dcafe01d2cfbd3d86ea2run>7
pool-1-thread-475b3c38ff368dcafe01d2cfbd3d86ea2run>6

スレッドの再利用が実現されていることがわかります。

FixedThreadPool が固定スレッドプールであるのはなぜですか?

ソースコード分析

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue());
    }

このソースコードから、コアスレッドの数 (corePoolSize) と最大スレッド数 (maximumPoolSize) が両方とも nThread であることがわかります。この場合、スレッドプールは拡張されず、スレッドの数は固定されます。

シングルスレッドプール SingleThreadExecutor

	ExecutorService executorService = Executors.newSingleThreadExecutor();

      for (int i = 0; i < 10; i++) {
          final int finalI = i;
          executorService.execute(new Runnable() {
              public void run() {
                  System.out.println(Thread.currentThread().getName()+"<thread->run>"+ finalI);
              }
          });

      }

SingleThreadExecutor にはスレッドが 1 つしか含まれていないのはなぜですか?

ソースコード分析

public static ExecutorService newSingleThreadExecutor() {
        return new Executors.FinalizableDelegatedExecutorService(new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue()));
    }

このソースコードから、コアスレッド数 (corePoolSize) と最大スレッド数 (maximumPoolSize) が両方とも 1 であることがわかります。 1つのスレッド。

Scheduled ThreadPool

	  int initDelay=10; //初始化延时
      int period=1;//初始化延迟过了之后，每秒的延时

      ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(10);

      scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
          @Override
          public void run() {
              System.out.println(Thread.currentThread().getName()+"<thread->run>");
          }
      },initDelay,period, TimeUnit.SECONDS);

このコードの効果は、プログラムの実行後 10 秒待機し、最初の結果を出力し、その後 1 秒ごとに結果を出力することです。

なぜ ScheduledThreadPool が推奨されないのですか?

ソースコード解析

public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, 2147483647, 10L, TimeUnit.MILLISECONDS, new ScheduledThreadPoolExecutor.DelayedWorkQueue());
    }

ScheduledThreadPoolの最大スレッド数(maximumPoolSize)は整数の最大値2147483647となっており、これはスレッドを無制限に作成することと同等であることがわかります。スレッドはメモリを必要とするため、メモリオーバーフローが発生します。通常のマシンでは、これほど多くのスレッドを作成するためにそれほど大きなメモリを使用することはありません。

ThreadPoolExecutor はスレッドプールを作成します (強く推奨)

	ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10, 20,
              2L, TimeUnit.SECONDS, new ArrayBlockingQueue<>(5),
              Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());

      for (int i = 0; i < 12; i++) {
          final int finalI = i;
          threadPoolExecutor.execute(new Runnable() {
              public void run() {
                  System.out.println(Thread.currentThread().getName()+"<thread->run>"+ finalI);
              }
          });
      }

ThreadPoolExecutor の 7 つのパラメータの詳細な説明

	public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) {
        
    }

corePoolSize: コアスレッドの数。これらのスレッドは一度作成されると破棄されず、常に存在します。スレッドプールにはデフォルトではスレッドがありません。タスクが到着すると、ThreadFactory を通じてスレッドが作成され、常に存在します。
maximumPoolSize: スレッドの最大数。非コアスレッドの数 = minimumPoolSize-corePoolSize. 非コアスレッドの数は、実際にはスケーラブルスレッドの数であり、破棄される可能性があります。
keepAliveTime: 非コアスレッドのアイドル状態の生存時間。拡張によって生成された非コアスレッドの数が keepAliveTime 後もアイドル状態のままである場合、これらの非コアスレッドは破棄されます。
unit: keepAliveTime の時間単位 (例: 秒)
workQueue: 待機エリア。 >corePoolSize のタスクが来ると、そのタスクは workQueue のブロッキングキューに格納され、他のスレッドが処理するのを待ちます。
threadFactory: スレッドファクトリ。スレッドを作成する方法。
ハンドラー: 拒否戦略。 >最大スレッド数 workQueue の容量に達すると、拒否ポリシー

workQueue

ArrayBlockingQueue: 境界付きブロッキングキューが実行されます。キューにはサイズ制限があり、容量を超えると、拡張または拒否ポリシーがトリガーされます。

	public ArrayBlockingQueue(int capacity) {
        this(capacity, false);
    }

LinkedBlockingQueue: 無制限のブロッキングキュー。キューにはサイズ制限がないため、メモリオーバーフローが発生する可能性があります。

	 public LinkedBlockingQueue() {
        this(2147483647);
    }

handler

AbortPolicy: 例外を直接スローします。

	public static class AbortPolicy implements RejectedExecutionHandler {
        public AbortPolicy() {
        }

        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            throw new RejectedExecutionException("Task " + r.toString() + " rejected from " + e.toString());
        }
    }

DiscardPolicy: 操作は実行されません。タスクをサイレントに破棄します

	public static class DiscardPolicy implements RejectedExecutionHandler {
        public DiscardPolicy() {
        }

        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        }
    }

DiscardOldestPolicy: 最長の既存タスクを破棄します

	public static class DiscardOldestPolicy implements RejectedExecutionHandler {
        public DiscardOldestPolicy() {
        }

        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                e.getQueue().poll();
                e.execute(r);
            }

        }
    }

CallerRunsPolicy: タスクを送信したスレッドにタスクを処理させます

	public static class CallerRunsPolicy implements RejectedExecutionHandler {
        public CallerRunsPolicy() {
        }

        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                r.run();
            }

        }
    }

threadFactory

	ThreadFactory threadFactory = Executors.defaultThreadFactory();

      threadFactory.newThread(new Runnable() {
          @Override
          public void run() {
              System.out.println("threadFactory");
          }
      }).start();

如何触发拒绝策略和线程池扩容？

	ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10, 20,
              2L, TimeUnit.SECONDS, new ArrayBlockingQueue<>(5),
              Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());

      for (int i = 0; i < 26; i++) { //并发数26
          final int finalI = i;
          threadPoolExecutor.execute(new Runnable() {
              public void run() {
                  System.out.println(Thread.currentThread().getName()+"<thread->run>"+ finalI);
              }
          });
      }
      /**
       * 核心线程数=10，最大线程数=20，故可扩容线程数=20-10
       * BlockingQueue的大小为5，故等待区的大小为5，也就是当并发数<=核心线程数+5不会扩容，并发数大于16才会扩容
       *
       * 触发扩容：并发数>核心线程数+阻塞队列的大小
       * 对于这段代码，如果来了26个并发，10个并发会被核心线程处理，5个会在等待区，剩下11个会因为等待区满了而触发扩容
       * 因为这里最多能够扩容10个，这里却是11个，所以会触发拒绝策略
       */

为什么这段代码会触发拒绝策略

对于这段代码，如果来了26个并发，10个并发会被核心线程处理，5个会在等待区，剩下11个会因为等待区满了而触发扩容，但是又因为因为这里最多能够扩容10个，这里却是11个，所以会触发拒绝策略。

怎么触发扩容

触发扩容：并发数>核心线程数（corePoolSize）+阻塞队列（workQueue）的大小

使用Java纯手写一个线程池

以上がJavaスレッドプールを作成する方法の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。

Java Integer int 线程 Thread 并发

声明：

この記事はyisu.comで複製されています。侵害がある場合は、admin@php.cn までご連絡ください。

前の記事：Springboot でコードの実行時間をカウントする方法次の記事：Springboot でコードの実行時間をカウントする方法

続きを見る

Javaスレッドプールを作成する方法

スレッド プールの利点

ExecutorService executorService = Executors.newCachedThreadPool(); for (int i = 0; i < 10; i++) { final int finalI = i; executorService.execute(new Runnable() { public void run() { System.out.println(Thread.currentThread().getName()+"<thread->run>"+ finalI); } }); }

ExecutorService executorService = Executors.newSingleThreadExecutor(); for (int i = 0; i < 10; i++) { final int finalI = i; executorService.execute(new Runnable() { public void run() { System.out.println(Thread.currentThread().getName()+"<thread->run>"+ finalI); } }); }

public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) { }

如何触发拒绝策略和线程池扩容？

関連記事

スレッドプールの利点