Sama seperti manusia dilahirkan, tua, sakit dan mati, benang juga harus melalui empat keadaan berbeda: mulai (menunggu), berlari, menggantung dan berhenti. Keempat keadaan ini dapat dikontrol melalui metode di kelas Thread. Metode yang terkait dengan empat keadaan di kelas Thread diberikan di bawah ini.
// Menunda dan membangunkan thread
public void resume(); // Tidak direkomendasikan untuk digunakan
public void suspend( ); // Tidak direkomendasikan untuk digunakan
tidur kosong statis publik (milis panjang);
tidur kosong statis publik (milis panjang, int nanos);
// Hentikan rangkaian pesan
public void stop(); // Tidak direkomendasikan untuk digunakan
interupsi kekosongan publik();
// Dapatkan status rangkaian pesan
boolean publik isAlive();
boolean publik isInterrupted();
boolean statis publik terputus ( );
// metode bergabung
public void join() melempar InterruptedException;
Thread tidak mengeksekusi kode dalam metode run segera setelah dibuat, tetapi berada dalam status menunggu. Saat thread berada dalam status menunggu, Anda dapat mengatur berbagai atribut thread melalui metode kelas Thread, seperti prioritas thread (setPriority), nama thread (setName), dan jenis thread (setDaemon).
Ketika metode start dipanggil, thread mulai mengeksekusi kode dalam metode run. Thread memasuki status berjalan. Anda dapat menggunakan metode isAlive dari kelas Thread untuk menentukan apakah thread sedang berjalan. Ketika thread dalam keadaan berjalan, isAlive mengembalikan nilai true. Ketika isAlive mengembalikan false, thread mungkin dalam keadaan menunggu atau dalam keadaan berhenti. Kode berikut menunjukkan peralihan antara tiga keadaan pembuatan thread, berjalan dan berhenti, dan menghasilkan nilai kembalian isAlive yang sesuai.
LifeCycle kelas publik memperluas Thread
{
menjalankan kekosongan publik()
{
ke dalam n = 0;
sementara ((++n) < 1000);
}
public static void main(String[] args) memunculkan Pengecualian
{
LifeCycle thread1 = LifeCycle baru();
System.out.println("isAlive: " + thread1.isAlive());
thread1.mulai();
System.out.println("isAlive: " + thread1.isAlive());
thread1.join(); // Tunggu hingga thread thread1 berakhir sebelum melanjutkan eksekusi
System.out.println("thread1 telah berakhir!");
System.out.println("isAlive: " + thread1.isAlive());
}
}
Hasil dari menjalankan kode di atas:
Setelah thread mulai mengeksekusi metode run, thread tidak akan keluar hingga metode run selesai. Namun, selama eksekusi thread, ada dua metode yang dapat digunakan untuk menghentikan sementara eksekusi thread. Kedua metode ini adalah suspend dan sleep. Setelah menggunakan suspend untuk menangguhkan thread, Anda dapat membangunkan thread melalui metode resume. Setelah menggunakan sleep untuk membuat thread tertidur, thread hanya dapat berada dalam status siap setelah waktu yang ditentukan (setelah thread tidur berakhir, thread mungkin tidak langsung dijalankan, tetapi hanya memasuki status siap, menunggu sistem menjadwalkan) .
Meskipun penangguhan dan melanjutkan dapat dengan mudah menangguhkan dan membangunkan thread, menggunakan kedua metode ini dapat menyebabkan beberapa hal yang tidak terduga terjadi. Oleh karena itu, kedua metode ini ditandai sebagai tidak digunakan lagi (protes), yang menunjukkan bahwa dalam kedua metode ini mungkin akan dihapus di masa mendatang jdk. versi, jadi cobalah untuk tidak menggunakan kedua metode ini untuk mengoperasikan thread. Kode berikut menunjukkan penggunaan metode sleep, suspend, dan resume.
kelas publik MyThread memperluas Thread
{
kelas SleepThread memperluas Thread
{
menjalankan kekosongan publik()
{
mencoba
{
tidur(2000);
}
tangkapan (Pengecualian e)
{
}
}
}
menjalankan kekosongan publik()
{
sementara (benar)
System.out.println(java.util.Date().getTime());
}
public static void main(String[] args) memunculkan Pengecualian
{
Utas MyThread = baru MyThread();
SleepThread sleepThread = thread.SleepThread baru();
sleepThread.start(); // Mulai menjalankan thread sleepThread
sleepThread.join(); // Menunda thread sleepThread selama 2 detik
thread.mulai();
bendera boolean = false;
sementara (benar)
{
sleep(5000); // Tunda thread utama selama 5 detik
bendera = !bendera;
jika (bendera)
thread.suspend();
kalau tidak
thread.resume();
}
}
}
Ada dua hal yang perlu diperhatikan saat menggunakan metode tidur:
1. Metode tidur memiliki dua bentuk kelebihan beban. Salah satu bentuk kelebihan beban tidak hanya dapat mengatur milidetik, tetapi juga nanodetik (1.000.000 nanodetik setara dengan 1 milidetik). Namun, mesin virtual Java pada sebagian besar platform sistem operasi tidak akurat dalam nanodetik. Oleh karena itu, jika nanodetik disetel untuk tidur, mesin virtual Java akan mengambil milidetik paling dekat dengan nilai ini.
2. Saat menggunakan metode sleep, Anda harus menggunakan throws atau try{…}catch{…}. Karena metode run tidak dapat menggunakan throws, Anda hanya dapat menggunakan try{…}catch{…} akan memunculkan InterruptedException ketika menginterupsi thread menggunakan metode interupsi (metode ini akan dibahas di 2.3.3). Metode tidur didefinisikan sebagai berikut:
Ada tiga cara untuk mengakhiri thread.
1. Gunakan tanda keluar untuk membuat thread keluar secara normal, yaitu thread berakhir ketika metode run selesai.
2. Gunakan metode stop untuk menghentikan thread secara paksa (metode ini tidak disarankan karena penghentian, seperti penangguhan dan melanjutkan, juga dapat memberikan hasil yang tidak terduga).
3. Gunakan metode interupsi untuk menginterupsi thread.
1. Hentikan thread menggunakan tanda keluar
Ketika metode run dijalankan, thread akan keluar. Namun terkadang metode yang dijalankan tidak pernah berakhir. Misalnya, thread digunakan dalam program server untuk memantau permintaan klien, atau tugas lain yang memerlukan pemrosesan siklik. Dalam hal ini, tugas-tugas ini biasanya ditempatkan dalam satu perulangan, seperti perulangan while. Jika Anda ingin loop berjalan selamanya, Anda dapat menggunakan while(true){...} untuk menanganinya. Tetapi jika Anda ingin membuat perulangan while keluar dalam kondisi tertentu, cara paling langsung adalah dengan menyetel tanda tipe boolean, dan menyetel tanda ini ke benar atau salah untuk mengontrol apakah perulangan while keluar. Contoh penghentian thread menggunakan tanda keluar diberikan di bawah ini.
ThreadFlag kelas publik memperluas Thread
{
keluar boolean volatil publik = false;
menjalankan kekosongan publik()
{
sementara (!keluar);
}
public static void main(String[] args) memunculkan Pengecualian
{
ThreadFlag thread = ThreadFlag baru();
thread.mulai();
sleep(5000); //Thread utama tertunda selama 5 detik
thread.exit = true; // Hentikan thread thread
thread.join();
System.out.println("Thread keluar!");
}
}
2. Gunakan metode stop untuk mengakhiri thread
Gunakan metode stop untuk menghentikan secara paksa thread yang sedang berjalan atau ditangguhkan. Kita dapat menggunakan kode berikut untuk mengakhiri thread:
3. Gunakan metode interupsi untuk mengakhiri thread
Menggunakan metode interupsi untuk mengakhiri thread dapat dibagi menjadi dua situasi:
(1) Thread dalam keadaan diblokir, seperti menggunakan metode tidur.
(2) Gunakan while(!isInterrupted()){...} untuk menentukan apakah thread terputus.
Dalam kasus pertama menggunakan metode interupsi, metode tidur akan memunculkan pengecualian InterruptedException, sedangkan dalam kasus kedua thread akan keluar secara langsung. Kode di bawah ini menunjukkan penggunaan metode interupsi pada kasus pertama.
kelas publik ThreadInterrupt memperluas Thread
{
menjalankan kekosongan publik()
{
mencoba
{
tidur(50000); // tunda 50 detik
}
menangkap (InterruptedException e)
{
Sistem.keluar.println(e.getMessage());
}
}
public static void main(String[] args) memunculkan Pengecualian
{
Utas utas = ThreadInterrupt() baru;
thread.mulai();
System.out.println("Tekan tombol apa saja dalam waktu 50 detik untuk menghentikan thread!");
Sistem.dalam.baca();
thread.interrupt();
thread.join();
System.out.println("Thread telah keluar!");
}
}
tidur terganggu
Threadnya sudah keluar!
Catatan: Ada dua metode di kelas Thread untuk menentukan apakah thread diakhiri melalui metode interupsi. Salah satunya adalah metode statis interupsi(), dan yang lainnya adalah metode non-statis isInterrupted(). Perbedaan antara kedua metode ini adalah interupsi digunakan untuk menentukan apakah thread saat ini terputus, sedangkan isInterrupted dapat digunakan untuk menentukan apakah thread saat ini terputus. thread lain terputus. Oleh karena itu, while (!isInterrupted()) juga dapat diganti dengan while (!Thread.interrupted()).