Copy kode kodenya sebagai berikut:
// Mulai rangkaian pesan
kekosongan publik mulai();
menjalankan kekosongan publik();
// 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 thread
boolean publik isAlive();
boolean publik isInterrupted();
boolean statis publik terputus ( );
// metode bergabung
public void join() melempar InterruptedException;
1. Membuat dan menjalankan thread
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.
Copy kode kodenya sebagai berikut:
paket bab2;
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());
}
}
Harap dicatat bahwa metode join digunakan dalam kode di atas. Fungsi utama dari metode ini adalah untuk memastikan bahwa program terus berjalan setelah metode run thread selesai.
Hasil dari menjalankan kode di atas:
isAlive: salah
isAlive: benar
thread1 telah berakhir!
isAlive: salah
2. Tangguhkan dan bangunkan thread
Setelah thread mulai mengeksekusi metode run, thread tidak akan keluar hingga metode run selesai. Namun, selama eksekusi thread, Anda dapat menghentikan sementara eksekusi thread melalui dua metode. Kedua metode ini adalah suspend dan sleep. Setelah menggunakan penangguhan untuk menangguhkan thread, Anda dapat mengaktifkannya 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, penggunaan kedua metode ini dapat menyebabkan beberapa hal yang tidak terduga terjadi. Oleh karena itu, kedua metode ini ditandai sebagai tidak berlaku 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.
Copy kode kodenya sebagai berikut:
paket bab2;
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();
}
}
}
Di permukaan, efek penggunaan sleep dan suspend serupa, namun metode sleep tidak setara dengan suspend. Perbedaan terbesar di antara keduanya adalah Anda dapat menggunakan metode penangguhan di satu thread untuk menangguhkan thread lainnya. Misalnya, dalam kode di atas, thread thread ditangguhkan di thread utama. Sleep hanya berfungsi pada thread yang sedang dijalankan. Dalam kode di atas, sleepThread dan thread utama tidur masing-masing selama 2 detik dan 5 detik. Saat menggunakan sleep, ketahuilah bahwa Anda tidak dapat menidurkan satu thread di thread lain. Misalnya menggunakan metode thread.sleep(2000) pada metode utama tidak dapat membuat thread thread tidur selama 2 detik, tetapi hanya dapat membuat thread utama tidur selama 2 detik.
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 menyetel 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. Melempar atau mencoba{...}menangkap{...} harus digunakan saat menggunakan metode tidur. Karena metode run tidak dapat menggunakan lemparan, Anda hanya dapat menggunakan try{...}catch{...}. Ketika thread sedang tidur dan metode interupsi (metode ini akan dibahas di 2.3.3) digunakan untuk menginterupsi thread, sleep akan memunculkan InterruptedException. Metode tidur didefinisikan sebagai berikut:
Copy kode kodenya sebagai berikut:
public static void sleep (milis panjang) memunculkan InterruptedException
public static void sleep (milis panjang, int nanos) menampilkan InterruptedException
3. Tiga cara untuk mengakhiri thread
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, gunakan thread 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.
Copy kode kodenya sebagai berikut:
paket bab2;
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!");
}
}
Bendera keluar, exit, didefinisikan dalam kode di atas. Jika exit benar, perulangan while akan keluar, dan nilai default exit adalah false. Saat mendefinisikan exit, kata kunci Java volatil digunakan. Tujuan dari kata kunci ini adalah untuk menyinkronkan exit, yang berarti hanya satu thread yang dapat mengubah nilai exit pada saat yang bersamaan.
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:
thread.stop();
Walaupun menggunakan kode di atas dapat menghentikan thread, namun menggunakan metode stop sangat berbahaya, seperti halnya mematikan daya komputer secara tiba-tiba dan bukannya mematikan sesuai prosedur normal, dapat menimbulkan hasil yang tidak terduga metode berhenti.
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.
Copy kode kodenya sebagai berikut:
paket bab2;
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!");
}
}
Hasil dari menjalankan kode di atas adalah sebagai berikut:
Copy kode kodenya sebagai berikut:
Tekan tombol apa saja dalam waktu 50 detik untuk menghentikan thread!
tidur terganggu
Threadnya sudah keluar!
Setelah memanggil metode interupsi, metode tidur memunculkan pengecualian dan kemudian mengeluarkan pesan kesalahan: tidur terganggu.
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()).