Bagaimana untuk membuat kolam benang Java

Faedah kumpulan benang

• dapat merealisasikan penggunaan semula benang dan mengelakkan penciptaan semula dan memusnahkan benang. Mencipta benang dan memusnahkan benang adalah sangat mahal untuk CPU.

• Anda boleh mengehadkan bilangan maksimum benang yang boleh dibuat dan melaraskan parameter kumpulan benang secara dinamik mengikut prestasi mesin anda sendiri untuk meningkatkan prestasi aplikasi.

• Menyediakan fungsi seperti pelaksanaan berjadual dan kawalan serentak.

• Pengurusan rangkaian bersatu.

Lima cara untuk mencipta kumpulan benang

1: Kumpulan benang cache (tidak disyorkan)

2: Kumpulan benang kapasiti tetap (tidak disyorkan)

3: Kumpulan utas tunggal (tidak disyorkan)

4: Kumpulan utas tugas berjadual (tidak disyorkan)

5: Cipta kumpulan utas melalui kaedah pembinaan ThreadPoolExecutor (dibangunkan oleh Alibaba Manual ini amat disyorkan)

Empat cara pertama untuk mencipta kumpulan benang semuanya dicipta melalui kaedah statik Pelaksana.

Cached ThreadPool

	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);
                }
            });
        }

Mengapa kumpulan thread cache tidak disyorkan?

Analisis kod sumber

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);
    }

Melalui dua coretan kod di atas, kita dapat melihat bahawa maksimumPoolSize CachedThreadPool ialah nilai maksimum Integer 2147483647, yang bersamaan dengan penciptaan benang tanpa had memerlukan ingatan Ya, ini akan menyebabkan limpahan memori, dan mesin biasa tidak menggunakan ingatan yang begitu besar untuk mencipta sejumlah besar benang.

Kolam benang kapasiti tetap FixedThreadPool

newFixedThreadPool(int num), num ialah bilangan benang tetap yang ingin kami tentukan

	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);
              }
          });
      }

Output:

pool-1-thread-5run>4
pool-1-thread-4run>3
pool-1-thread-5 lari>5
benang-1-benang-3lari>2
benang-1-benang-3lari>8
benang-1-benang-3< benang- >lari>9
pool-1-thread-2run>1
pool-1-thread-1run>0
pool-1- benang- 5lari>7
pool-1-benang-4run>6

Ia boleh dilihat bahawa penggunaan semula benang telah dicapai.

Mengapa FixedThreadPool kumpulan benang tetap?

Analisis kod sumber

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

Ia boleh dilihat daripada kod sumber ini bahawa bilangan utas teras (corePoolSize) dan bilangan maksimum utas (maximumPoolSize) adalah kedua-duanya nThreads, kerana hanya dalam ini cara, kumpulan benang tidak akan dikembangkan , bilangan benang ditetapkan.

Kumpulan utas tunggal 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);
              }
          });

      }

Mengapa SingleThreadExecutor hanya mengandungi satu utas?

Analisis kod sumber

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

Seperti yang dapat dilihat daripada kod sumber ini, bilangan utas teras (corePoolSize) dan bilangan maksimum utas (maximumPoolSize) adalah kedua-duanya 1, jadi ia hanya mengandungi satu benang.

ThreadPool Berjadual

	  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);

Kesan kod ini ialah: tunggu 10 saat selepas program dijalankan, kemudian keluarkan hasil pertama, dan kemudian keluarkan hasilnya setiap 1 saat.

Mengapa ScheduledThreadPool tidak disyorkan?

Analisis kod sumber

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

Dapat dilihat bahawa bilangan maksimum utas (maximumPoolSize) ScheduledThreadPool ialah nilai maksimum Integer 2147483647, yang bersamaan dengan penciptaan utas tanpa had dan mencipta utas memerlukan ingatan, jadi Ia akan menyebabkan limpahan memori, dan mesin biasa tidak menggunakan ingatan yang begitu besar untuk mencipta sebilangan besar benang.

ThreadPoolExecutor mencipta kumpulan benang (sangat disyorkan)

	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);
              }
          });
      }

Penjelasan terperinci tentang tujuh parameter ThreadPoolExecutor

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

• corePoolSize: bilangan corePoolSize . Sebaik sahaja benang ini dicipta, ia tidak akan dimusnahkan dan akan sentiasa wujud. Kumpulan benang tidak mempunyai benang secara lalai Apabila tugasan tiba, benang akan dibuat melalui ThreadFactory dan akan sentiasa wujud.

• maximumPoolSize: Bilangan maksimum utas. Bilangan utas bukan teras = maksimumPoolSize-corePoolSize Bilangan utas bukan teras sebenarnya ialah bilangan utas boleh skala dan mungkin musnah.

• keepAliveTime: Masa hidup terbiar bagi urutan bukan teras. Apabila bilangan utas bukan teras yang dijana melalui pengembangan masih melahu selepas keepAliveTime, utas bukan teras ini akan dimusnahkan.

• unit: unit masa keepAliveTime, contohnya: saat

• workQueue: kawasan menunggu. Apabila tugasan > corePoolSize datang, tugasan itu akan disimpan dalam baris gilir menyekat workQueue, menunggu urutan lain diproses.

• kilang benang: Kilang benang. Satu cara untuk mencipta benang.

• pengendali: Strategi penolakan. Apabila datang > bilangan maksimum urutan + kapasiti workQueue, dasar penolakan akan dilaksanakan

workQueue

ArrayBlockingQueue: baris gilir sekatan bersempadan. Barisan beratur mempunyai had saiz Apabila kapasiti melebihi, dasar pengembangan atau penolakan akan dicetuskan.

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

LinkedBlockingQueue: Baris sekatan tidak terhad, baris gilir tidak mempunyai had saiz dan boleh menyebabkan limpahan memori.

	 public LinkedBlockingQueue() {
        this(2147483647);
    }

pengendali

AbortPolicy: Buang pengecualian terus

	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: Tiada operasi dilakukan. Buang tugasan secara senyap

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

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

BuangPolisiLama: Buang tugasan sedia ada yang paling lama

	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: Biarkan urutan yang menyerahkan tugasan memproses tugasan

	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纯手写一个线程池

Atas ialah kandungan terperinci Bagaimana untuk membuat kolam benang Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!