Bagaimana untuk melaksanakan kaedah pembinaan kolam benang Java

1. Prakata

Untuk merealisasikan pengaturcaraan serentak, konsep proses telah diperkenalkan. Sesuatu proses adalah bersamaan dengan tugas sistem pengendalian. Pelbagai proses melaksanakan tugas pada masa yang sama, dengan itu mencapai pengaturcaraan serentak dan membolehkan pelaksanaan yang lebih pantas.

Namun, kerana proses itu tidak cukup ringan, sumber yang digunakan dengan mencipta dan memusnahkan proses tidak boleh diabaikan. Jika bilangan proses tidak besar, penggunaan sumber ini boleh diterima, tetapi jika proses kerap dibuat dan dimusnahkan. Itu banyak perbelanjaan.

Apa yang perlu kita lakukan?

Untuk menyelesaikan masalah ini, orang ramai telah memperkenalkan alat yang lebih ringan - benang.

Benang juga dipanggil proses ringan. Penciptaan dan pemusnahannya menggunakan kurang sumber daripada proses. Tetapi bagaimana jika terdapat sejumlah besar tugas dan multi-threading tidak dapat menahan penciptaan dan kemusnahan yang kerap? Pada masa ini, kumpulan benang keluar untuk menyelesaikan masalah!

Kolam benang adalah serupa dengan kolam pemalar rentetan Java.

Menggunakan benang VS tidak menggunakan benang

Apabila menggunakan benang, cuma ambil benang terus dari kolam.
Apabila benang tidak digunakan, masukkan benang ini ke dalam kolam
Semua orang tahu bahawa proses mencari pekerjaan mungkin seperti ini .

Penyerahan resume
Ujian bertulis
Temuduga
tawaran
Apabila kita sampai ke temuduga, akan ada dua situasi.

Jika anda lulus, syarikat akan menghubungi anda untuk memberitahu anda dan menghantar tawaran kepada anda
Jika anda gagal, dan secara amnya syarikat akan tidak memberitahu anda bahawa anda gagal , tetapi tidak memberitahu anda sama sekali bahawa anda tidak, kerana syarikat mungkin meletakkan anda dalam "kumpulan simpanan bakat" mereka.
Andaikan syarikat sedang mencari 50 orang, dan semasa tempoh pengambilan musim gugur, ia menghantar tawaran kepada 50 orang. Tetapi sebenarnya hanya 35 orang sahaja yang datang melapor. Pada masa ini, baki 15 orang terus menangkap 15 orang daripada kumpulan simpanan bakat dan membuat tawaran secara langsung.

Mungkin beberapa masa telah berlalu pada masa ini, dan syarikat tiba-tiba menghubungi anda untuk memaklumkan anda telah diambil bekerja Adakah anda ingin datang? Operasi ini bersamaan dengan menggunakan benang terus dari kolam.

Ini ialah contoh mencari pekerjaan untuk menerangkan maksud kumpulan benang.

3. Apakah yang dimaksudkan dengan parameter kaedah pembinaan kolam benang kaedah pembinaan ThreadPoolExecutor?

Adalah dinyatakan dalam "Manual Pembangunan Java Alibaba" bahawa sumber benang mesti disediakan melalui kumpulan benang, dan penciptaan benang tidak dibenarkan untuk dipaparkan dalam aplikasi Di satu pihak, penciptaan benang lebih diseragamkan dan pembangunan boleh dikawal secara munasabah. Sebaliknya, pengurusan terperinci benang diserahkan kepada kumpulan benang, yang mengoptimumkan overhed sumber.

Kelas "ThreadPoolExecutor" ialah satu set kelas yang disediakan oleh perpustakaan standard Java untuk menggunakan kumpulan benang.

ThreadPoolExecutor mempunyai empat kaedah pembinaan. Setiap satu mengandungi parameter yang berbeza dan digunakan dalam senario yang berbeza.

Kami akan memperkenalkan kaedah pembinaan dengan parameter terbanyak.

ThreadPoolExecutor threadPoolExecutor=new ThreadPoolExecutor (
int corePoolSize,
int maximumPoolSize ,
long keepAliveTime ,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
 ThreadFactory threadFactory,
 RejectedExecutionHandler handler
 )

1.corePoolSize Bilangan utas teras

2.maximumPoolSize Bilangan maksimum utas

Untuk bilangan utas teras dan bilangan utas maksimum Anda mungkin tidak begitu memahami fungsinya. Berikut ialah contoh pekerja yang akan bekerja.

Bilangan utas teras ialah pekerja rasmi syarikat, membolehkan mereka memancing buat seketika. Jika anda ditemui, anda tidak akan dipecat. (Setara dengan benang dalam kumpulan benang yang tidak akan musnah walaupun mereka tidak melakukan apa-apa)

Bilangan maksimum benang ialah bilangan pekerja tetap + pekerja sementara dalam syarikat, tetapi pekerja sementara di sini adalah di sini untuk mengambil kesempatan daripadanya. Anda akan dipecat selepas tempoh masa tertentu. (Bersamaan dengan benang dalam kolam benang yang dimusnahkan)

3.keepAliveTime menerangkan berapa lama pekerja sementara boleh memancing

4.unit ialah unit masa, iaitu unit keepAliveTime. .

5.workQueue blocking queue, yang mengatur tugasan yang akan dilakukan oleh thread pool

6.threadFactory thread creation method, gunakan parameter ini untuk menetapkan kaedah penciptaan thread yang berbeza

7.RejectedExecutionHandler strategi penolakan pengendali. Apabila baris gilir tugasan penuh dan tugasan baharu datang, apakah yang perlu kita lakukan pada masa ini?

(1): Tugas terbaharu tidak lagi diperlukan

(2): Tugas tertua tidak lagi diperlukan

(3): Menyekat menunggu

( 4) Buka: Pengecualian lontar

由于ThreadPoolExecutor使用起来比较复杂，最多有7个参数。标准库为此又为程序员们提供了一组其他的类。相当于对ThreadPoolExecutor又进行了一层封装。1

: Buat kumpulan benang dengan bilangan benang yang tetap.

newFixedThreadPool

2.

 ExecutorService Service1   =  Executors.newFixedThreadPool (20);

: Buat bilangan pembolehubah kumpulan benang

newCachedThreadPool

3.

ExecutorService Service2   = Executors.newCachedThreadPool ();

: Buat kumpulan benang dengan hanya satu utas

newSingleThreadExecutor

4.

ExecutorService Service3  = Executors.newSingleThreadExecutor ();

: Buat kumpulan benang yang boleh menetapkan masa tunda.

newScheduledThreadPool

4 Simulasikan pelaksanaan kumpulan benang

ExecutorService Service4   = Executors.newScheduledThreadPool (20);

模拟实现一个线程池的核心操作：
.:将任务加到线程池中--submit。
.:使用Worker类描述一个工作线程，Runnable来描述一个任务。
.:创建一个BlockingQueue阻塞队列组织所有任务。
.:每个Worker要做的事情就是不停的从阻塞队列里获取任务并执行。
.:指定线程池中的线程最大数目，如果超过这个数目就不要再继续创建线程了。

Pelaksanaan kod:

我们创建一个线程池并让它不停的创建进程打印hello

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * Created with IntelliJ IDEA.
 *
 
 * @Description: 模拟实现线程池的使用
 */
public class ThreadDemo0327_2 {
    public static void main (String[] args) throws IOException, InterruptedException {
        ThreadPoll threadPoll=new ThreadPoll ();
        for (int i = 0 ; i <10  ; i++) {
            threadPoll.submit (new Runnable () {
                @Override
                public void run () {
                    System.out.println ("hello");
                }
            });
        }
    }
}

class  Worker extends  Thread{
    public   BlockingQueue<Runnable> queue=null;
    public Worker(BlockingQueue<Runnable> queue){
        this.queue=queue;
    }

    @Override
    public void run () {
        //工作线程的具体逻辑
        //需要从阻塞队列中取任务.
        while (true){
            try {
                Runnable command=queue.take ();
                //通过run来执行具体任务
                command.run ();
            }catch (InterruptedException e){
                e.printStackTrace ();
            }
        }
    }
}

class  ThreadPoll{
    //包含一个阻塞队列，用来组织任务
  public   BlockingQueue<Runnable> queue=new LinkedBlockingQueue<> ();

    //这个list就用来存放当前的工作线程.
    public  List<Thread> works=new ArrayList<> ();

    public  int MAX_WORKER_COUNT=10;

    //通过这个方法，把任务加入到线程池中
    //submit不光可以把任务放到阻塞队列中，也可以负责创建线程
    public  void submit(Runnable command) throws IOException, InterruptedException {
        if(works.size ()<MAX_WORKER_COUNT){
            //如果当前工作线程的数量不足线程数目上线，就创建出新的线程
            //工作线程就专门找一个类完成
            //worker内部要哦能够取到队列的内容，就要把这个队列实例通过worker的构造方法传过去
            Worker worker=new Worker (queue);
            worker.start ();
            works.add (worker);
        }
        queue.put (command);
    }
}

运行效果：

可以看到，打印了10个hello。

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