Apakah prinsip, penggunaan dan kaedah pengoptimuman prestasi kumpulan benang Java?

1. Apakah benang dan kumpulan benang

Benang ialah unit asas penjadualan masa dalam sistem pengendalian.

Kolam benang boleh difahami sebagai kolam dengan benang, iaitu bekas ini hanya boleh mengandungi benang. Bekas ini mempunyai saiz yang berbeza, ia boleh memuatkan 7 atau 8 keping, atau 3 atau 4 keping. Bekas juga boleh diisi, tetapi terdapat nilai maksimum, seperti 12. Contohnya, kumpulan benang di sini biasanya mengandungi 5 utas dan boleh mengandungi sehingga 12 utas. Pada masa ini, terdapat lima orang yang perlu menggunakan kumpulan benang, jadi dia mengambil lima utas bagaimana jika dua orang datang kemudian? ia. Tetapi kolam saya boleh memuatkan 12. Bagaimana saya boleh melakukannya jika saya hanya mempunyai 5 utas saya pasti perlu memasang beberapa utas lagi, jika tidak, ia tidak akan cukup jika ada lebih ramai orang sedang menghasilkan 2. Jumlah benang mencecah 7. Pada masa ini baki 2 orang tidak perlu menunggu dan boleh digunakan terus. Jika 6 orang datang, pada masa ini, kolam saya mungkin hanya tinggal 5 utas saya boleh menghasilkan 5 utas, tetapi masih ada seorang yang perlu menunggu di suatu tempat. Saya tidak boleh membiarkan orang menunggu tanpa tujuan. Saya akan menemui 5 najis Anda boleh duduk di sana dan menunggu benang. Pada masa ini, 10 orang datang satu demi satu benang saya hanya boleh digunakan oleh 4 orang. t have a seat here You want to Memang tidak selesa untuk mengatakan tidak secara langsung tanpa melihat ke tempat lain terlebih dahulu, dan saya perlu memikirkan beberapa strategi penolakan. . . , saya rasa masih ramai orang menggunakan kumpulan benang saya Dengan begitu ramai orang menggunakannya, bagaimana jika seseorang terus menduduki kumpulan benang saya? Jika tidak, satu benang hanya boleh digunakan selama 1 minit, dan ia akan dikitar semula serta-merta selepas digunakan. Jika anda ingin menggunakannya semula, beratur semula dan tunggu. Dengan cara ini, perniagaan benang saya menjadi lebih baik dan lebih baik selagi seseorang menggunakannya, ia akan terus berjalan.

Adakah ia agak seperti restoran atau kedai bufet? hanya boleh menunggu di depan pintu, pelanggan di restoran datang dan menunggu di luar sedikit lagi. Pelanggan di restoran tidak boleh makan terlalu lama (biasanya apabila tiada tempat duduk), kira-kira 2 jam, dan mereka akan keluar selepas makan.

Berdasarkan penerangan saya di atas, saya mungkin boleh menentukan apa yang ada dalam kumpulan benang?

Berapa banyak benang dipasang, berapa banyak benang boleh dipasang, berapa lama benang boleh dikekalkan, benang tempat menunggu, cara menolak, mencipta benang

1.1, Mengapa menggunakan utas

Penjalanan atur cara mesti bergantung pada proses dan unit pelaksanaan sebenar proses itu ialah utas.

• Panggilan perkhidmatan dalam sistem. Sistem bergantung pada proses untuk dijalankan Terdapat banyak perkhidmatan dalam sistem, dan terdapat interaksi antara perkhidmatan. Operasi berbilang perkhidmatan bergantung pada operasi berbilang benang. Panggilan dan pertukaran data antara perkhidmatan bergantung pada memori antara proses untuk interaksi data Pada masa yang sama, benang juga boleh membina ruang memori mereka sendiri. Bergantung pada penjadualan sumber dan interaksi data antara proses.

• Berbilang rangkaian boleh meningkatkan prestasi pelaksanaan program. Sebagai contoh, jika terdapat rumah seluas 90 meter persegi, ia mengambil masa 30 minit untuk seorang membersihkannya, dan hanya 10 minit untuk tiga orang membersihkannya.

Dalam banyak program, berbilang urutan perlu disegerakkan atau saling eksklusif untuk menyelesaikan kerja secara selari.

Benang lebih ringan daripada proses, jadi kos mencipta dan memusnahkan benang menjadi lebih kecil.

Benang meningkatkan prestasi Walaupun benang selari secara makroskopik, ia bersiri secara mikroskopik. Benang tidak dapat meningkatkan prestasi dari perspektif CPU, tetapi jika beberapa utas terlibat dalam menunggu sumber (seperti IO, menunggu input), berbilang benang membenarkan utas lain dalam proses untuk terus melaksanakan dan bukannya keseluruhan proses disekat, oleh itu meningkatkan kadar penggunaan CPU, dari perspektif ini prestasi akan dipertingkatkan.

Dalam kes berbilang CPU atau berbilang teras, menggunakan benang bukan sahaja selari pada peringkat makro, tetapi juga pada peringkat mikro.

1.2. Mengapa menggunakan thread pool

Berbilang rangkaian boleh meningkatkan prestasi pelaksanaan program

• Contohnya, semasa makan bufet, apabila ada cukup tempat duduk Apabila orang ramai, bufet adalah yang paling menguntungkan, dan ia juga boleh meningkatkan kadar makan dan kepuasan pelanggan. Sekiranya terdapat 200 orang makan dan terdapat 100 tempat makan, dan setiap orang makan selama satu jam secara purata, maka 200 orang itu akan menghabiskan makanan dalam masa dua jam. Jika hanya ada 10 tempat duduk, kira-kira 20 jam akan diambil untuk 200 orang makan. Fikirkan betapa tidak puas hati pelanggan lain jika mereka menunggu dengan cemas untuk makan.

• Kerusi dalam bufet adalah benang apabila cukup banyak, lebih ramai orang boleh makan, tetapi tidak bermakna lebih banyak, lebih baik, tidak semestinya ada 200 setiap satu Walaupun 200 pelanggan datang untuk makan, kita masih perlu menilai faktor perkakasan asas seperti sama ada terdapat cukup tukang masak di restoran, sama ada wanita pembersih boleh membersihkan, dan sama ada terdapat cukup pinggan di restoran. Ini bersamaan dengan konfigurasi sistem, yang memerlukan beberapa syarat perkakasan penting seperti memori dan pemprosesan CPU.

Membuat/memusnahkan utas disertakan dengan overhed sistem Mencipta/memusnahkan utas terlalu kerap akan sangat menjejaskan kecekapan pemprosesan (selagi utas itu terus dilaksanakan, ia tidak akan dimusnahkan)

• -berkesan untuk memulakan thread untuk melaksanakan tugas ini? Kebetulan kumpulan benang menyimpan cache benang dan boleh menggunakan benang terbiar sedia ada untuk melaksanakan tugas baharu, mengelakkan overhed sistem yang disebabkan oleh T1+T3 Sudah tentu, benang teras yang masih ada juga akan menggunakan sumber CPU

Terlalu banyak benang serentak boleh merampas sumber sistem dan menyebabkan penyekatan

• kita tahu bahawa benang boleh berkongsi sumber sistem. mungkin membawa kepada sumber sistem yang tidak mencukupi Sekiranya berlaku penyekatan, penggunaan kumpulan benang boleh mengawal bilangan maksimum benang serentak dan mengelakkan masalah di atas

Lakukan beberapa pengurusan benang yang mudah.

• Contohnya: pelaksanaan tertunda, strategi pelaksanaan gelung bermasa, dsb. boleh dilaksanakan dengan baik menggunakan kumpulan benang

Kebaikan kumpulan benang

Tingkatkan Penggunaan benang

• Pastikan ia digunakan apabila ada perniagaan dan dikeluarkan apabila tiada perniagaan Gunakan benang secara rasional untuk mengelakkan pembaziran sumber

Tingkatkan kelajuan tindak balas program

• Jika ia diuruskan secara seragam oleh kumpulan benang, peruntukan sumber dijadualkan menggunakan kumpulan penjadualan bersatu apabila benang digunakan , penciptaan dan pemusnahan benang yang memakan masa boleh dielakkan Benang boleh digunakan secara langsung.

Memudahkan pengurusan bersatu objek benang

• Kolam benang boleh memastikan peruntukan bersatu dan pengurusan benang.

Boleh mengawal bilangan maksimum mata wang

• Pelayan mempunyai had atas untuk penggunaan benang, dan penggunaan benang juga menggunakan banyak sumber , jadi kumpulan benang Ia boleh mengawal sumber benang dengan baik dan mengelakkan pembaziran.

2. Penggunaan kumpulan benang dalam java

Kelas ThreadPoolExecutor ialah kelas kumpulan benang di java, yang boleh digunakan untuk mengumpulkan benang.

// 根据上面的描述大概分析一下线程都需要什么及参数的解析
// corePoolSize 核心线程数，就是上面说的装了多少个线程
// maximumPoolSize 最大线程数，就是上面说的能装多少线程
// keepAliveTime 存活时间，就是上面说的线程可以保留多长时间
// TimeUnit 这个是时间单位，有时、分、秒、天等等，是存活时间的单位
// BlockingQueue<Runnable> 这是一个等待队列，就是上面显示的线程等待区
// ThreadFactory 线程工厂，就是上面描述的如何创建线程，由谁创建
// RejectedExecutionHandler 拒绝策略，就是上面显示的如何拒绝，是直接拒绝还是婉拒
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
                          BlockingQueue<Runnable> workQueue)
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory)
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,RejectedExecutionHandler handler)
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler)

Seperti yang anda lihat, ia memerlukan parameter berikut:

• corePoolSize (diperlukan): bilangan utas teras. Secara lalai, benang teras akan sentiasa bertahan, tetapi apabila allowCoreThreadTimeout ditetapkan kepada benar, benang teras juga akan tamat masa dan dikitar semula.

• maximumPoolSize (diperlukan): Bilangan maksimum benang yang boleh dimuatkan oleh kumpulan benang. Apabila bilangan utas aktif mencapai nilai ini, tugas baharu seterusnya akan disekat.

• keepAliveTime (diperlukan): tamat masa melahu benang. Jika masa ini melebihi masa, benang bukan teras akan dikitar semula. Jika allowCoreThreadTimeout ditetapkan kepada benar, benang teras juga akan tamat masa dan dikitar semula.

• unit (diperlukan): Menentukan unit masa untuk parameter keepAliveTime. Yang biasa digunakan ialah: TimeUnit.MILLISECONDS (milisaat), TimeUnit.SECONDS (saat), TimeUnit.MINUTES (minit).

• workQueue (diperlukan): Barisan tugas. Objek boleh jalan yang diserahkan melalui kaedah execute() kumpulan benang akan disimpan dalam parameter ini. Ia dilaksanakan menggunakan baris gilir menyekat.

• threadFactory (pilihan): Kilang benang. Digunakan untuk menentukan cara urutan baharu dicipta untuk kumpulan benang.

• pengendali (pilihan): strategi penolakan. Strategi tepu yang perlu dilaksanakan apabila bilangan maksimum benang dicapai.

2.1. Prinsip kerja kumpulan benang

2.2.2 Keputusan:

pool-1-thread-1========0
pool-1-thread-3========2
pool-1-thread- 3========4
pool-1-thread-2========1
pool-1-thread-3=========5
pool-1-thread-2========8
pool-1-thread-5========7
pool-1-thread-1==== ====3
pool-1-thread-4========6
Pengecualian dalam thread "utama" java.util.concurrent.RejectedExecutionException: Task java.util.concurrent.FutureTask@ 61e717c2 ditolak daripada java.util.concurrent.ThreadPoolExecutor@66cd51c3[Berjalan, saiz kolam = 5, utas aktif = 2, tugas beratur = 0, tugas selesai = 7]
di java.util.concurrent.ThreadPoolExeculice$ (ThreadPoolExecutor.java:2063)
di java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:830)
di java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.execute(ThreadPool9)🎜 di java.util.concurrent.AbstractExecutorService.submit(AbstractExecutorService.java:112)
at com.halo.communication.ThreadTest.main(ThreadTest.java:10)

承猡超过了线程池可容纳的大小，线程池使用默认拒绝策略拒绝多余线程执行，就市理。上面执行的线程数到thread-5，5是线程池的默认最大线程数。然后执行for循环20次，进行执行到8的时候出现异常，说明线程池已经超载满负荷执行，所以执行，所以线片片。 🎜>

Atas ialah kandungan terperinci Apakah prinsip, penggunaan dan kaedah pengoptimuman prestasi kumpulan benang Java?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!