1. bergabung dengan utas :
Selama eksekusi thread, terkadang Anda ingin thread lain dieksekusi terlebih dahulu, seperti membagi masalah besar menjadi banyak masalah kecil, menugaskan thread ke setiap masalah kecil, namun setelah semua masalah kecil diproses, biarkan thread utama melakukan operasi selanjutnya. Saat ini, kita dapat memanggil metode join() dari thread lain di thread utama untuk memblokir thread pemanggil (di sini, thread utama).
Contoh kode:
Copy kode kodenya sebagai berikut:
paket org.frzh.thread;
kelas publik JoinThread memperluas Thread{
//Sediakan konstruktor berparameter untuk menyetel nama thread
jointhread publik (nama string) {
super(nama);
}
menjalankan kekosongan publik() {
untuk (int saya = 0; saya < 100; saya++) {
Sistem.keluar.println(getName() + " " + i);
}
}
public static void main(String[] args) {
//Mulai thread anak
jointhread baru("thread baru").start();
untuk (int saya = 0; saya < 100; saya++) {
jika (saya == 20) {
JoinThread jt = new JoinThread("utas yang akan digabungkan");
jt.mulai();
//Thread utama memanggil metode join dari thread jt, maka thread utama harus menunggu jt selesai dieksekusi sebelum dapat dieksekusi
mencoba {
jt.join();
} tangkapan (InterruptedException e) {
// TODO Blok tangkapan yang dibuat secara otomatis
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName() + " " +i);
}
}
}
Awalnya ada tiga set thread (dua sub-thread dan satu thread utama). Ketika i=20, thread utama diblokir dan harus menunggu hingga "thread yang bergabung" dieksekusi sebelum sempat dieksekusi, jadi begitulah. hanya dua thread yang dieksekusi setelahnya.
Tiga bentuk metode join() yang kelebihan beban:
join(): tunggu hingga thread yang digabungkan selesai dieksekusi;
join (milis panjang): Waktu terlama untuk menunggu thread yang digabungkan dieksekusi adalah beberapa milidetik. Setelah itu, meskipun thread yang digabungkan belum selesai dieksekusi, thread tersebut tidak akan menunggu lebih lama lagi;
join(long millis, int nanos): Waktu maksimum untuk menunggu thread yang digabungkan dieksekusi adalah milis milidetik + nanos mikrodetik. (Metode ini pada dasarnya tidak berguna).
2: Utas latar belakang :
Ada thread yang berjalan di latar belakang, dan tugasnya adalah melayani thread lainnya. Thread ini disebut "thread latar belakang", "thread daemon", atau "thread elf". Ketika semua thread latar depan mati, thread latar belakang akan mati secara otomatis.
Contoh kode:
Copy kode kodenya sebagai berikut:
paket org.frzh.thread;
kelas publik DaemonThread memperluas Thread{
menjalankan kekosongan publik() {
untuk (int saya = 0; saya < 1000; saya++) {
Sistem.keluar.println(getName() + " " +i);
}
}
public static void main(String[] args) {
DaemonThread dt = DaemonThread baru();
//Atur thread ini sebagai thread latar belakang
dt.setDaemon(benar);
dt.mulai();
untuk (int saya = 0; saya < 10; saya++) {
System.out.println(Thread.currentThread().getName() + " " + i);
}
//Thread latar depan berakhir, maka thread latar belakang dt juga akan berakhir, sehingga tidak akan mengeksekusi 999
}
}
Thread utama default ke thread latar depan, sub-thread yang dibuat oleh thread latar depan default ke thread latar depan, dan sub-thread yang dibuat oleh thread latar belakang default ke thread latar belakang.
3. Benang tidur (tidur):
Metode join sebelumnya adalah membiarkan thread pemanggil menunggu hingga thread yang digabungkan selesai dieksekusi sebelum melanjutkan, sedangkan metode sleep() adalah membiarkan thread pemanggil memblokir selama jangka waktu tertentu sebelum memasuki kembali status siap dan menunggu untuk menjadi dijadwalkan. Oleh karena itu sering digunakan untuk menghentikan sementara eksekusi program.
Contoh kode:
Copy kode kodenya sebagai berikut:
paket org.frzh.thread;
import java.util.Date;
Thread Tidur kelas publik{
public static void main(String[] args) {
untuk (int saya = 0; saya < 10; saya++) {
System.out.println("Waktu saat ini: " + Tanggal baru());
mencoba {
Thread.tidur(1000);
} tangkapan (InterruptedException e) {
// TODO Blok tangkapan yang dibuat secara otomatis
e.printStackTrace();
}
}
}
}
Dua metode kelebihan beban dari metode sleep():
static void sleep (long millis): Biarkan thread saat ini berhenti sejenak selama milimili detik dan masuk ke status pemblokiran. Metode ini dipengaruhi oleh ketepatan dan keakuratan pengatur waktu sistem dan penjadwal thread.
static void sleep (long millis, int nanos): Menjeda mill milidetik + nanos mikrodetik dan memasuki status pemblokiran. Ini juga akan dipengaruhi oleh keakuratan dan keakuratan pengatur waktu sistem dan penjadwal thread. Pada dasarnya tidak diperlukan.
4. Hasil benang :
Metode yield() agak mirip dengan metode tidur. Metode ini juga dapat menjeda thread yang sedang berjalan, namun tidak akan memblokir thread, tetapi hanya mentransfernya ke status siap (perhatikan bahwa ini bukan status pemblokiran). Metode yield() hanya akan memberikan kesempatan pada thread dengan prioritas yang sama atau prioritas lebih tinggi untuk dieksekusi, sehingga thread dapat dijadwal ulang kembali untuk melanjutkan eksekusi setelah memanggil metode ini.
Contoh kode:
Copy kode kodenya sebagai berikut:
paket org.frzh.thread;
kelas publik YieldThread memperluas Thread{
Utas Hasil publik() {
}
public YieldThread(Nama string) {
super(nama);
}
menjalankan kekosongan publik() {
untuk (int saya = 0; saya < 100; saya++) {
Sistem.keluar.println(getName() + " " +i);
jika (saya == 20) {
//Thread saat ini menghasilkan
Thread.hasil();
}
}
}
public static void main(String[] args) {
//Memulai dua thread secara bersamaan
YieldThread yt1 = new YieldThread("Lanjutan");
//Tetapkan yt1 sebagai prioritas tertinggi
yt1.setPriority(Utas.MAX_PRIORITY);
yt1.mulai();
YieldThread yt2 = new YieldThread("tingkat rendah");
yt2.setPriority(Utas.MIN_PRIORITY);
yt2.mulai();
/*
* Jika prioritas tidak ditetapkan untuk thread, prioritas kedua thread adalah sama, sehingga kedua thread akan dieksekusi secara bergantian, dan ketika yield dipanggil, thread lainnya akan dieksekusi;
* Namun, setelah menetapkan prioritas di atas untuk kedua thread masing-masing, eksekusi thread lanjutan baru saja dimulai. Ketika i=20, hasil dipanggil, tetapi karena metode hasil saja
* Memberikan kesempatan eksekusi pada thread dengan prioritas yang sama atau lebih tinggi, sehingga thread tingkat tinggi masih dieksekusi saat ini dan tidak akan diberikan ke thread tingkat rendah
*/
}
}
5: Ubah prioritas thread :
Ini relatif sederhana, cukup panggil metode instance metode setPriority(int prioritas). Setiap thread secara default memiliki prioritas yang sama dengan thread induknya, dan thread utama secara default memiliki prioritas normal (5). Java memberikan prioritas dari 1 hingga 10, dan Anda juga dapat menggunakan tiga konstanta statis:
MAX_PRIORITAS:10
PRIORITAS_MIN:1
NORM_PRIORITAS:5
Catatan: Meskipun Java menyediakan 10 prioritas, sistem yang berbeda mendukung prioritas yang berbeda, jadi cobalah untuk menghindari penggunaan angka antara 1 dan 10 secara langsung, dan gunakan konstanta statis untuk memastikan portabilitas yang baik.