Dengan mewarisi Thread dan mengatasi run(), tugasan yang perlu dilakukan ditakrifkan dalam kaedah run. Subkelas yang dicipta boleh melaksanakan kaedah thread dengan memanggil kaedah start().
Dengan mewarisi kelas utas yang dilaksanakan oleh Thread, berbilang utas tidak boleh berkongsi pembolehubah contoh kelas utas. Objek Thread yang berbeza perlu dicipta dan sumber secara semula jadi tidak dikongsi.
1) Tentukan kelas UserThread dan warisi kelas Thread
2) Gantikan kaedah run( )
3) Buat objek UserThread
4) Panggil kaedah mula( )
Sumber data tidak dikongsi dan berbilang urutan menyelesaikan tugasan mereka sendiri. Sebagai contoh, jika tiga tingkap tiket menjual tiket pada masa yang sama, dan masing-masing menjual tiket sendiri, akan ada masalah tiga tingkap tiket menjual tiket yang sama.
Anda perlu mentakrifkan kelas terlebih dahulu untuk melaksanakan antara muka Runnable dan mengatasi kaedah run() antara muka ini ialah badan pelaksanaan benang. Kemudian buat objek kelas pelaksanaan Runnable sebagai sasaran parameter untuk mencipta objek Thread ini ialah objek thread sebenar.
Menggunakan kelas utas yang melaksanakan antara muka Runnable untuk mencipta objek boleh merealisasikan perkongsian sumber antara utas.
1) Tentukan kelas UserRun dan laksanakan antara muka Runnble
2) Gantikan kaedah run()
3) Buat objek kelas UserRun
4) Buat objek daripada kelas Thread, Objek kelas UserRun digunakan sebagai parameter pembina kelas Thread
5) Mulakan thread
Perkongsian sumber data, beberapa utas menyelesaikan tugas bersama-sama (berbilang utas berkongsi sumber untuk mencipta objek utas). Sebagai contoh, tiga tingkap tiket (tiga utas) menjual tiket pada masa yang sama (tiket dalam kelas MyThread), dan tiga utas menggunakan sumber bersama-sama.
Antaramuka Boleh Panggil adalah seperti versi antara muka Boleh Dijalankan yang dipertingkatkan Kaedah panggilan() yang disediakannya akan berfungsi sebagai badan pelaksanaan utas dan membenarkan nilai pulangan.
Objek Boleh Panggil tidak boleh digunakan secara langsung sebagai sasaran objek Thread, kerana antara muka Boleh Panggil ialah antara muka baharu dalam Java5 dan bukan sub-antara muka antara muka Runnable.
Untuk penyelesaian kepada masalah ini, antara muka Masa Depan diperkenalkan antara muka ini boleh menerima nilai pulangan panggilan(). antara muka Runnable dan boleh digunakan sebagai Thread Sasaran objek.
1) Tentukan kelas UserCallable dan laksanakan antara muka Boleh Panggil
2) Gantikan kaedah panggilan()
3) Buat objek UserCallable
4) Buat subkelas FutureTask of Objek antara muka RunnableFuture, parameter pembina ialah objek UserCallable
5) Buat objek kelas Thread, parameter pembina ialah objek FutureTask
6) Mulakan utas
Perkongsian sumber data, beberapa utas menyelesaikan tugas bersama-sama (berbilang utas berkongsi sumber untuk mencipta objek utas). Sebagai contoh, tiga tingkap tiket (tiga utas) menjual tiket pada masa yang sama (tiket dalam kelas MyThread), dan tiga utas menggunakan sumber bersama-sama. Pada masa yang sama, selepas panggilan benang selesai, akan terdapat nilai pulangan .
Kelas pemasa Timer dan TimerTask boleh digunakan sebagai cara lain untuk melaksanakan urutan.
Pemasa ialah kemudahan benang yang digunakan untuk menjadualkan tugasan untuk pelaksanaan kemudian dalam urutan latar belakang. Tugasan boleh dijadualkan untuk dilaksanakan sekali atau berulang kali pada selang masa yang tetap. Ia boleh dianggap sebagai pemasa dan TimerTask boleh dijadualkan.
TimerTask ialah kelas abstrak yang melaksanakan antara muka Runnable, jadi ia mempunyai keupayaan berbilang benang.
1) Tentukan kelas UserTimerTask dan warisi kelas abstrak TimerTask
2) Buat objek kelas UserTask
3) Buat objek kelas Pemasa dan tetapkan strategi pelaksanaan tugas
Urutan yang dibuat oleh kelas pemasa lebih banyak digunakan untuk memproses tugas berjadual dan sumber data tidak dikongsi antara urutan dan berbilang rangkaian menyelesaikan tugasan mereka sendiri.
Kolam benang boleh dibuat melalui kelas alat Pelaksana.
Tingkatkan kelajuan tindak balas sistem Apabila tugasan tiba, dengan menggunakan semula utas sedia ada, ia boleh dilaksanakan serta-merta tanpa menunggu penciptaan utas baharu.
Kurangkan penggunaan sumber sistem dan kurangkan penggunaan yang disebabkan oleh penciptaan dan pemusnahan benang dengan menggunakan semula benang sedia ada.
Kawal bilangan utas serentak dengan mudah. Kerana jika benang dibuat tanpa had, ia boleh menyebabkan OOM disebabkan penggunaan memori yang berlebihan, dan boleh menyebabkan penukaran CPU yang berlebihan.
① Cipta benang bersaiz tetap melalui Executors.newFixedThreadPool(5 ) Pool
② Tulis semula kaedah run() kelas Runnable dan gunakan kumpulan benang untuk melaksanakan tugas
③Shutdown() menutup kumpulan benang
Buat kumpulan benang bersaiz tetap untuk berkongsi sumber data dan membenarkan berbilang benang melengkapkan tugas bersama.
① Buat kumpulan single-thread melalui Executors.newSingleThreadExecutor( )
② Tulis semula kaedah run( ) kelas Runnable dan gunakan kumpulan benang untuk melaksanakan tugas
③ Shutdown( ) menutup kumpulan benang
Kolam benang hanya mencipta satu urutan untuk melaksanakan tugas.
① Cipta seberapa banyak urutan yang mungkin melalui Executors.newCachedThreadPool() Pool
② Tulis semula kaedah run() kelas Runnable dan gunakan pool thread untuk melaksanakan tugas
③Shutdown() menutup pool thread
Kaedah ini akan mencipta seberapa banyak benang yang mungkin untuk menyelesaikan tugasan, seperti dalam kes, walaupun hanya ada 10 gambar tiket, tetapi kumpulan benang menjana sekurang-kurangnya 12 utas.
① Dibuat oleh Executors.newScheduledThreadPool(5) A kumpulan benang dengan bilangan benang teras tetap (bilangan minimum benang untuk dikekalkan, benang tidak akan dikitar semula selepas penciptaan), dan benang dilaksanakan secara kerap seperti yang dirancang.
② Tulis semula kaedah run( ) kelas Runnable dan gunakan kumpulan benang untuk melaksanakan tugas
③ Shutdown( ) menutup kumpulan benang
Cipta kumpulan benang berkala yang menyokong pelaksanaan tugas berjadual dan berkala (parameter kali pertama ialah masa tunda pelaksanaan, dan parameter kedua ialah selang pelaksanaan).
① Cipta kumpulan utas melalui Executors.newWorkStealingPool()
② Tulis semula kaedah run() kelas Runnable, panggil objek kelas Runnable melalui objek kelas Thread dan gunakan kumpulan benang untuk melaksanakan tugas
③ Sleep() membenarkan utas utama menunggu kanak-kanak benang untuk menyelesaikan pelaksanaan, atau anda boleh menggunakan pembilang
④Shutdown( ) menutup kumpulan thread
Oleh kerana setiap thread mempunyai baris gilir tugasnya sendiri, kerana tugas semakin berkurangan, ia mungkin menyebabkan ketidakseimbangan beban CPU. Kaedah ini boleh memanfaatkan kelebihan CPU berbilang teras dengan tugasan yang lebih sedikit boleh "mencuri" tugasan daripada utas dengan lebih banyak tugas, dengan itu mengimbangi pelaksanaan tugas pada setiap CPU.
Atas ialah kandungan terperinci Apakah cara untuk mencipta pelbagai benang di Jawa?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!