Java Creation Threads (Runnable Interface and Thread Class)
Dalam kebanyakan kasus, utas dibuat dengan instantiasi objek utas. Java mendefinisikan dua cara:
Berikut ini menjelaskan setiap metode secara bergantian.
Menerapkan antarmuka runnable
Cara termudah untuk membuat utas adalah dengan membuat kelas yang mengimplementasikan antarmuka yang dapat dijalankan. Runnable Abstracts Unit Eksekusi Kode. Anda dapat membuat utas untuk setiap objek dengan mengimplementasikan antarmuka Runnable. Untuk mengimplementasikan antarmuka runnable, kelas hanya perlu menerapkan metode run () sederhana, yang dinyatakan sebagai berikut:
public void run ()
Di run (), Anda dapat mendefinisikan kode untuk membangun utas baru. Sangat penting untuk memahami yang berikut: metode run () dapat memanggil metode lain, merujuk ke kelas lain, dan menyatakan variabel seperti utas utama. Satu -satunya perbedaan adalah bahwa run () menetapkan entri eksekusi utas bersamaan lainnya dalam program. Saat run () kembali, utas berakhir.
Setelah Anda membuat kelas yang mengimplementasikan antarmuka Runnable, Anda perlu instantiate objek kelas utas di dalam kelas. Kelas utas mendefinisikan beberapa konstruktor. Apa yang akan kami gunakan adalah sebagai berikut:
Thread (Runnable Threadob, String ThreadName)
Dalam konstruktor ini, Threadob adalah instance yang mengimplementasikan kelas antarmuka yang dapat dijalankan. Ini menentukan titik awal untuk eksekusi utas. Nama utas baru ditentukan oleh threadname.
Setelah utas baru dibuat, tidak berjalan sampai metode start () dipanggil, yang didefinisikan dalam kelas utas. Pada dasarnya, mulai () menjalankan panggilan untuk menjalankan (). Metode start () dinyatakan sebagai berikut:
void start ()
Contoh berikut adalah membuat utas baru dan memulainya berjalan:
// Buat Thread Kedua.Class Newthread Runnable {Thread T; : " + t); t.start (); // Mulai utas} // Ini adalah titik masuk untuk utas kedua. public void run () {coba {untuk (int i = 5; i> 0; i -) {System.out.println ("Thread Child:" + i); out .println ("keluar dari utas anak."); 0; );} System.out.println (" Di Newthread Constructor, objek utas baru dibuat oleh pernyataan berikut:
t = utas baru (ini, "utas demo");
Ini menunjukkan bahwa dalam objek ini Anda ingin utas baru memanggil metode run (). Kemudian, mulai () dipanggil, dan eksekusi utas dimulai dengan metode run (). Ini menyebabkan benang anak untuk Loop memulai eksekusi. Setelah menelepon start (), konstruktor newthread kembali ke main (). Ketika utas utama dipulihkan, ia mencapai loop untuk. Kedua utas terus berjalan, berbagi CPU sampai loop mereka berakhir. Output dari program ini adalah sebagai berikut:
Utas anak: utas [Demo Thread, 5, Main] Thread Utama: 5Child Thread: 5Child Thread: 4Main Thread: 4Child Thread: 3Child Thread: 2Main Thread: 3Child Thread: 1e Xiting Child Thread.main Thread: 2Main Thread: 1Main Thread Keluar dari .
Seperti yang disebutkan sebelumnya, dalam program multi-threaded, utas utama biasanya harus menjadi utas terakhir yang berakhir. Bahkan, untuk beberapa JVM lama, jika utas utama berakhir sebelum utas anak, sistem runtime Java dapat "menggantung". Program yang disebutkan di atas memastikan bahwa utas utama berakhir pada akhirnya, karena utas utama tidur selama 1000 milidetik, sedangkan utas anak hanya 500 milidetik. Ini menyebabkan benang anak berakhir sebelum utas utama berakhir. Singkatnya, Anda akan melihat cara yang lebih baik untuk menunggu utas berakhir.
Utas diperpanjang
Cara lain untuk membuat utas adalah dengan membuat kelas baru yang memperluas kelas utas, dan kemudian membuat instance dari kelas itu. Ketika kelas mewarisi utas, itu harus membebani metode run (), yang merupakan entri ke utas baru. Ini juga harus memanggil metode start () untuk memulai eksekusi utas baru. Berikut ini adalah menulis ulang program sebelumnya dengan kelas utas yang diperluas:
// Buat utas kedua dengan memperpanjang threadclass newThread Extends Thread {newThread () {// Buat utas baru super ("Demo Thread"); (); // Mulai utas} // ini adalah titik masuk untuk utas kedua. "Utas anak:" + i); ");}} class extendThread {public static void main (string args []) {newThread baru (); // Buat utas baru coba {for (int i = 5; i> 0; i--) {System. out ::::::::::::::: .println ("Utas utama:" + i); Utas utama terputus. ");} System.ou t.println (" Utas utama keluar. ");}} Program ini menghasilkan output yang sama dengan versi sebelumnya. Utas anak dihasilkan oleh objek newThread yang dipakai, yang berasal dari kelas utas. Perhatikan panggilan ke super () di newthread. Metode ini memanggil konstruktor utas dari formulir berikut:
Thread Publik (String ThreadName)
Di sini, threadname menentukan nama utas.
Pilih metode yang tepat
Pada titik ini, Anda pasti akan bertanya -tanya mengapa Java memiliki dua cara untuk membuat utas anak, mana yang lebih baik. Semua pertanyaan dikaitkan dengan satu titik. Kelas utas mendefinisikan berbagai metode yang dapat dikeluarkan oleh kelas yang diturunkan. Untuk semua metode, satu -satunya hal yang harus kelebihan beban adalah metode run (). Ini tentu saja metode yang sama diperlukan untuk mengimplementasikan antarmuka yang dapat dilalui. Banyak programmer Java percaya bahwa kelas harus diperpanjang hanya ketika mereka diperkuat atau dimodifikasi. Oleh karena itu, jika Anda tidak membebani metode utas lainnya, yang terbaik adalah mengimplementasikan hanya antarmuka yang dapat dijalankan. Tentu saja terserah Anda untuk memutuskan. Namun, di bagian lain dari bab ini, kami menerapkan kelas yang mengimplementasikan antarmuka runnable untuk membuat utas.