Kelas utas Java juga merupakan kelas objek, dan contohnya diwarisi dari java.lang.thread atau subkelasnya. Anda dapat membuat utas di Java dengan cara berikut. Mengeksekusi utas dapat memanggil metode start () dari utas:
Tapak utas = utas baru ();
thread.start ();
Dalam contoh di atas, kami tidak menulis kode yang berjalan untuk utas, sehingga utas berakhir setelah memanggil metode.
Ada dua cara untuk menulis kode yang dieksekusi ketika utas dijalankan: satu adalah dengan membuat instance dari subkelas utas dan mengganti metode run, dan yang kedua adalah mengimplementasikan antarmuka runnable saat membuat kelas. Selanjutnya kami akan menjelaskan kedua metode ini secara rinci:
Buat subkelas utas
Buat instance dari subkelas utas dan ganti metode run. Metode jalankan akan dieksekusi setelah memanggil metode start (). Contoh subkelas utas di atas dapat dibuat dan dijalankan dengan cara berikut:
kelas publik mythread memperluas utas {public void run () {System.out.println ("MyThread running"); }} Mythread mythread = myThread baru (); mytread.start ();Setelah utas dimulai, metode start akan segera kembali, dan tidak akan menunggu sampai metode run dieksekusi sebelum kembali. Ini seperti metode run dieksekusi pada CPU lain. Ketika metode run dieksekusi, string mythread berjalan akan dicetak.
Anda juga dapat membuat subclass anonim utas sebagai berikut:
Thread thread = thread baru () {public void run () {System.out.println ("Thread Running"); }}; thread.start ();Ketika metode run dari utas baru dijalankan, komputer akan mencetak string "Thread Running".
Menerapkan antarmuka runnable
Cara kedua untuk menulis kode eksekusi utas adalah dengan membuat instance baru dari kelas yang mengimplementasikan antarmuka java.lang.runnable, dan metode dalam contoh dapat dipanggil oleh utas. Berikut ini adalah contoh:
kelas publik MyRunnable mengimplementasikan runnable {public void run () {System.out.println ("MyRunnable Running"); }}Agar utas dapat menjalankan metode run (), perlu untuk melewati objek instance myrunnable ke dalam konstruktor kelas utas. Contohnya adalah sebagai berikut:
Thread thread = utas baru (myRunnable baru ());
thread.start ();
Saat utas berjalan, itu akan memanggil metode run yang mengimplementasikan antarmuka yang dapat dijalankan. "MyRunnable Running" akan dicetak dalam contoh di atas.
Demikian pula, Anda dapat membuat kelas anonim yang mengimplementasikan antarmuka runnable, seperti yang ditunjukkan di bawah ini:
Runnable myrunnable = new runnable () {public void run () {System.out.println ("runnable running"); }} Utas utas = utas baru (myRunnable); thread.start ();Buat subkelas atau implementasikan antarmuka yang dapat dijalankan?
Tidak ada jawaban yang pasti untuk mana dari dua metode ini yang lebih baik, dan mereka dapat memenuhi persyaratan. Menurut pendapat pribadi saya, saya lebih suka mengimplementasikan metode antarmuka runnable. Karena kumpulan utas dapat secara efektif mengelola utas yang mengimplementasikan antarmuka Runnable, jika kumpulan utas penuh, utas baru akan mengantri untuk dieksekusi sampai kumpulan utas menganggur. Dan jika utas diimplementasikan dengan mengimplementasikan subkelas utas, ini akan sedikit lebih rumit.
Kadang -kadang kita perlu mengintegrasikan dua cara menerapkan antarmuka yang dapat dijalankan dan subkelas utas secara bersamaan. Misalnya, instance yang mengimplementasikan subkelas utas dapat menjalankan beberapa utas yang mengimplementasikan antarmuka Runnable. Aplikasi khas adalah kumpulan utas.
Kesalahan Umum: Memanggil metode run () alih -alih metode start ()
Kesalahan umum yang dibuat dengan membuat dan menjalankan utas adalah memanggil metode run () utas alih -alih metode start (), seperti yang ditunjukkan di bawah ini:
Utas newThread = utas baru (myRunnable ());
newThread.run (); // harus mulai ();
Pada awalnya Anda tidak merasa ada yang salah, karena metode run () memang disebut sesuai keinginan. Namun, pada kenyataannya, metode run () tidak dieksekusi oleh utas baru yang baru saja dibuat, tetapi dieksekusi oleh utas saat ini yang membuat utas baru. Artinya, dieksekusi oleh utas yang mengeksekusi dua baris kode di atas. Untuk membuat utas baru yang dibuat, jalankan metode run (), metode start utas baru harus dipanggil.
Nama utas
Saat membuat utas, Anda dapat memberikan nama utas. Ini membantu kita membedakan utas yang berbeda. Misalnya: Jika beberapa utas ditulis ke System.out, kita dapat dengan mudah mengetahui utas mana yang dikeluarkan melalui nama utas. Contohnya adalah sebagai berikut:
MyRunnable runnable = new myrunnable (); thread thread = utas baru (runnable, "new thread"); thread.start (); System.out.println (thread.getName ());
Perlu dicatat bahwa karena MyRunnable bukan subclass dari utas, kelas MyRunnable tidak memiliki metode getName (). Anda bisa mendapatkan referensi ke utas saat ini dengan cara berikut:
Thread.currentThread ();
String threadName = thread.currentThread (). GetName ();
Contoh kode utas:
Ini contoh kecil. Pertama, output nama utas dari metode utama (). Utas ini dialokasikan oleh JVM. Kemudian buka 10 utas dan beri nama mereka 1 ~ 10. Setiap utas keluar setelah mengeluarkan namanya sendiri.
Public Class ThreadExample {public static void main (string [] args) {System.out.println (thread.currentThread (). getName ()); untuk (int i = 0; i <10; i ++) {utas baru ("" + i) {public void run () {System.out.println ("Thread:" + getName () + "running"); } }.awal(); }}}Perlu dicatat bahwa meskipun urutan utas awal dipesan, urutan eksekusi tidak dipesan. Dengan kata lain, Thread 1 belum tentu utas pertama yang mengeluarkan namanya ke konsol. Ini karena utas dieksekusi secara paralel daripada secara berurutan. JVM dan sistem operasi menentukan urutan eksekusi utas, dan urutan startup tidak harus sama dengan utas.
Di atas adalah kompilasi dari informasi yang dibuat oleh utas Java. Kami akan terus menambahkan informasi yang relevan di masa mendatang. Terima kasih atas dukungan Anda untuk situs web ini!