Contoh -contoh berikut terutama membahas dua masalah:
Pertanyaan 1. Kumpulan utas diperbaiki dalam ukuran, dengan asumsi 5. Lalu bagaimana efek operasi memasukkan 10 utas ke dalam kumpulan utas? Status utas lain?
Pertanyaan 2. Jadi, bagaimana Anda menghapus utas dari kumpulan utas, atau tepatnya, untuk membuat utas sebagai utas idle?
contoh:
paket com.dada.executorservice; impor java.util.concurrent.timeunit; Public Class Jobthread memperluas utas {// nama utas Public Jobthread (nama string, long threadId) {super (name); } @Override public void run () {// Jika utas utama berisi utas ini, itu akan berjalan saat (MainThread.threadnamemap.containsKey (this.getName ()))) {coba {System.out.println ("Nama utas: -----" + this.getName ()); Timeunit.seconds.sleep (4); } catch (Exception e) {E.PrintStackTrace (); }} System.out.println ("**************** BAWAH AKHIR, Nama utas: ***************" + this.getName ()); }} paket com.dada.executorservice; impor java.util.hashmap; impor java.util.concurrent.executorservice; impor java.util.concurrent.Executors; impor java.util.concurrent.timeunit; Public Class MainThread {public static int threadpool_size = 5; // menghasilkan executorService execorservice pool ukuran tetap pool ukuran tetap = executors.newfixedThreadPool (threadpool_size); // peta yang digunakan untuk menyimpan nama utas peta statis publik <string, string> threadnamemap = new HashMap <string, string> (); public static void main (string [] args) {// masukkan 10 utas ke dalam kumpulan utas, tetapi kumpulan utas hanya memungkinkan maksimum 5 utas, sehingga 5 utas lainnya menunggu (int i = 0; i <threadpool_size+5; i ++) {string threadname = getThreadname (i); threadnamemap.put (threadName, threadName); exec.execute (jobthread baru (threadname, i)); } System.out.println ("Ukuran tabel hash:" + threadnamemap.size ()); coba {System.out.println ("Thread utama tidur sebentar!"); Timeunit.seconds.sleep (3); } catch (Exception e) {E.PrintStackTrace (); System.out.println ("Bangun!"); } // Berikut ini digunakan untuk menghapus utas di kumpulan utas // lepas (0); // hapus (1); // lepas (2); } public static void removethread (int i) {threadnamemap.remove (getThreadName (i)); System.out.println ("Hapus Threadthread" + I + ", ukuran tabel hash:" + threadnamemap.size ()); } public static string getThreadName (int i) {return "threadName"+i; }} Langsung jalankan hasil kode:
ThreadName: ------ ThreadName0
Ukuran tabel hash: 10
Tidur sebentar di utas utama!
ThreadName: ------ ThreadName2
ThreadName: ------ ThreadName4
ThreadName: ------ ThreadName1
ThreadName: ------ ThreadName3
ThreadName: ------ ThreadName4
ThreadName: ------ ThreadName2
ThreadName: ------ ThreadName3
ThreadName: ------ ThreadName1
ThreadName: ------ ThreadName0
ThreadName: ------ ThreadName1
ThreadName: ------ ThreadName3
ThreadName: ------ ThreadName0
ThreadName: ------ ThreadName4
ThreadName: ------ ThreadName2
ThreadName: ------ ThreadName1
ThreadName: ------ ThreadName3
ThreadName: ------ ThreadName4
Kesimpulan:
Ditemukan dicetak: Nama utasnya berasal dari threadname0 ke threadname4, tidak ada nama lain.
Terbukti bahwa 10 utas ditempatkan ke dalam kumpulan benang, tetapi ukuran kumpulan benang adalah 5, dan hanya 5 utas yang dapat dialokasikan CPU. Yang berjalan adalah yang pertama dimasukkan ke dalam kumpulan utas, dan utas lainnya berada dalam keadaan siap (keadaan pemblokiran).
Setelah menghapus komentar, kode berjalan:
ThreadName: ------ ThreadName0
ThreadName: ------ ThreadName2
ThreadName: ------ ThreadName4
Ukuran tabel hash: 10
Tidur sebentar di utas utama!
ThreadName: ------ ThreadName1
ThreadName: ------ ThreadName3
Hapus Thread Thread0, Ukuran Tabel Hash: 9
Hapus Thread Thread1, ukuran tabel hash: 8
Hapus Thread Thread2, Ukuran Tabel Hash: 7
*************** Ujung utas, nama utas: ********* threadname2
*************** Ujung utas, nama utas: ********* threadname0
ThreadName: ------ ThreadName5
ThreadName: ------ ThreadName6
*************** Ujung utas, nama utas: ********* threadname1
ThreadName: ------ ThreadName4
ThreadName: ------ ThreadName7
ThreadName: ------ ThreadName3
ThreadName: ------ ThreadName6
ThreadName: ------ ThreadName5
ThreadName: ------ ThreadName7
ThreadName: ------ ThreadName4
ThreadName: ------ ThreadName3
ThreadName: ------ ThreadName5
ThreadName: ------ ThreadName6
ThreadName: ------ ThreadName7
ThreadName: ------ ThreadName4
ThreadName: ------ ThreadName3
Kesimpulan:
Dari hasilnya, kita dapat melihat bahwa sebelum menghapus utas, utas yang berjalan masih dari Thread0 ke Thread4. Setelah menghapus utas utas 0, thread baru utas baru mulai berjalan, dan itu masuk ke threadName7 secara berurutan.
Ringkasannya adalah sebagai berikut:
1. Kolam utas diperbaiki dalam ukuran, dengan asumsi itu 5. Lalu bagaimana efek operasi memasukkan 10 utas ke dalam kumpulan utas? Status utas lain?
A. Konsep kumpulan utas adalah Anda terus mendorong permintaan, tetapi hanya dapat menangani utas dengan kuota yang ditentukan, dan utas tambahan akan menunggu di dalamnya.
B. Ketika salah satu utas telah menyelesaikan pemrosesan (eksekusi bisnis selesai atau saat loop keluar), kumpulan utas akan secara otomatis mengambil pekerjaan dari antrian menunggu dan menggunakan utas idle untuk menjalankan pekerjaan. Pool utas mana di kumpulan utas yang berjalan harus didasarkan pada urutan yang ditempatkan.
2. Jadi cara menghapus utas dari kumpulan benang, atau tepatnya, untuk membuat utas sebagai benang idle?
Kumpulan utas tidak dapat memperoleh salah satu utas dan membunuhnya karena utas utama menggunakan kumpulan utas dan utas yang dibuka oleh utas utama berada pada level yang sama, dan tidak ada yang memiliki hak untuk mendominasi kelangsungan hidup pihak lain. Tetapi Anda dapat mengubah metode dan mencapai tujuan dengan cara yang bijaksana.
A. Utas utama memelihara tabel hash yang bisa menjadi hashmap. Nilai kuncinya sewenang -wenang, tetapi harus unik dan dapat secara unik menunjukkan utas.
B. Semua utas yang ditempatkan di kumpulan utas harus menghasilkan nilai kunci dan kemudian menyimpannya di hashmap ini.
C. Untuk utas kelas loop, seperti utas while (true). Suatu kondisi perlu ditambahkan untuk memverifikasi apakah kunci utas ini ada di hashmap di atas. Keluarlah loop while jika tidak ada.
D. Meskipun utas utama tidak dapat mendominasi kelangsungan hidup utas lain, ia dapat menempatkan atau menghapus hashmapnya sendiri. Pada titik ini, selama nilai kunci yang sesuai dari utas dihapus dari hashmap, utas akan secara otomatis keluar saat berikutnya loop.
Di atas adalah semua konten artikel ini. Saya berharap ini akan membantu untuk pembelajaran semua orang dan saya harap semua orang akan lebih mendukung wulin.com.