Mari kita amati beberapa perbedaan lain antara Thread dan Runnable dengan bantuan grafik perbandingan yang ditunjukkan di bawah ini:
Grafik perbandingan
| Dasar untuk Perbandingan | Benang | Runnable |
|---|---|---|
| Dasar | Setiap utas membuat objek unik dan dikaitkan dengan itu. | Beberapa utas berbagi objek yang sama. |
| Ingatan | Karena setiap utas membuat objek unik, dibutuhkan lebih banyak memori. | Karena banyak utas berbagi objek yang sama, memori yang digunakan lebih sedikit. |
| Memperluas | Di Jawa, pewarisan berganda tidak diizinkan karenanya, setelah sebuah kelas memperluas kelas Thread, ia tidak dapat memperluas kelas lainnya. | Jika kelas mendefinisikan utas yang mengimplementasikan antarmuka Runnable, ia memiliki peluang untuk memperluas satu kelas. |
| Menggunakan | Pengguna harus memperluas kelas utas hanya jika ingin menimpa metode lain di kelas Utas. | Jika Anda hanya ingin mengkhususkan metode run maka mengimplementasikan Runnable adalah pilihan yang lebih baik. |
| Kopel | Memperluas kelas Thread memperkenalkan kopling ketat karena kelas berisi kode kelas Thread dan juga pekerjaan yang ditugaskan ke utas | Menerapkan antarmuka Runnable memperkenalkan kopling longgar karena kode Thread terpisah dari pekerjaan Threads. |
Definisi Kelas Thread
Thread adalah kelas dalam paket java.lang . Kelas Thread memperluas kelas Object, dan mengimplementasikan antarmuka Runnable . Kelas Thread memiliki konstruktor dan metode untuk membuat dan beroperasi pada utas. Saat kami membuat banyak utas, setiap utas membuat objek unik dan dikaitkan dengan objek itu. Jika Anda membuat utas yang memperluas kelas Utas, lebih lanjut Anda tidak dapat memperluas kelas lain karena java tidak mendukung banyak pewarisan. Jadi, Anda harus memilih untuk memperluas kelas Thread hanya ketika Anda juga ingin mengganti beberapa metode lain dari kelas Thread. Mari kita lihat contoh membuat utas yang memperluas kelas Utas.
/ * Menentukan utas * / Kelas Mythread memperluas Utas {/ * pekerjaan utas * / public void run () {for (int i = 0; i <10; i ++) {System.Out.Println ("Child Thread" ); }} Kelas mainThread {/ * pekerjaan utas utama * / public static void main (String args []) {Mythread mt = new Mythread (); / * utas utama menciptakan utas anak * / mt.start (); untuk (int i = 0; i <10; i ++) {System.Out.Print ("Main Thread"); }}} / * Output * / Main Thread Main Thread Main Thread Main Thread Anak Thread Anak Thread Child Thread Anak Thread Main Thread Anak Thread Utama Thread Utama Thread Anak Thread Utama Thread Main Thread Main Thread Anak Thread Anak Thread Main Thread Dalam kode di atas, saya membuat kelas Mythread yang memperluas kelas Thread dan menimpa metode run dari kelas Thread. Di kelas yang berisi metode utama saya membuat objek thread (mt) dari kelas Mythread dan menggunakan objek thread dipanggil metode start (). Metode mulai memulai pelaksanaan utas dan pada saat yang sama JVM memanggil metode jalankan utas. Sekarang ada dua utas dalam program satu utas utama dan utas anak kedua dibuat oleh utas utama. Eksekusi kedua utas terjadi secara bersamaan, tetapi, output yang tepat tidak bisa dipura-pura.
Definisi Antarmuka Runnable
Runnable adalah antarmuka dalam paket java.lang . Menerapkan antarmuka Runnable kita dapat mendefinisikan utas. Antarmuka Runnable memiliki metode tunggal run (), yang diimplementasikan oleh kelas yang mengimplementasikan antarmuka Runnable. Ketika Anda memilih untuk mendefinisikan utas yang mengimplementasikan antarmuka Runnable, Anda masih punya pilihan untuk memperluas kelas lain. Saat Anda membuat banyak utas dengan mengimplementasikan antarmuka Runnable, masing-masing utas membagikan instance runnable yang sama. mari kita belajar bagaimana mendefinisikan utas menggunakan antarmuka Runnable.
/ * Menentukan utas * / Kelas Runnablethread mengimplementasikan Runnable {/ * pekerjaan utas * / public void run () {for (int i = 0; i <10; i ++) {System.Out.Println ("Child Thread" ); }} Kelas mainThread {/ * pekerjaan utas utama * / public static void main (String args []) {Mythread rt = new Mythread (); / * utas utama menciptakan objek runnable * / Utas t = Utas baru (rt); / * utas utama menciptakan utas anak dan melewati objek runnable * / t.start (); untuk (int i = 0; i <10; i ++) {System.Out.Print ("Main Thread"); }}} / * Output * / Main Thread Main Thread Main Thread Main Thread Anak Thread Anak Thread Child Thread Anak Thread Main Thread Anak Thread Utama Thread Utama Thread Anak Thread Utama Thread Main Thread Main Thread Anak Thread Anak Thread Main Thread Dalam kode di atas, saya membuat kelas Runnablethread yang mengimplementasikan antarmuka Runnable dan mendefinisikan pekerjaan utas dengan menerapkan metode run () dari antarmuka Runnable. Lalu saya membuat kelas mainthread yang berisi metode utama. Di dalam metode utama, saya mendeklarasikan objek runnable dari kelas Runnablethread dan meneruskan objek ini ke konstruktor Thread sambil mendeklarasikan sebuah thread. Dengan cara ini, saya menautkan objek utas (t) dengan objek runnable (rt). Kemudian objek thread memanggil metode start dari thread yang selanjutnya memanggil metode run dari kelas Runnablethread. Jika saya tidak menautkan objek runnable dengan objek Thread, maka metode start threads akan memanggil metode run kelas Thread. Sekarang, lagi-lagi ada dua utas dalam kode, utas utama dan utas utama membuat utas anak keduanya dieksekusi secara bersamaan tetapi output yang tepat tidak pernah bisa dianggap.
Perbedaan Utama Antara Thread dan Runnable di Jawa
- Setiap utas yang dibuat dengan memperluas kelas Utas membuat objek unik untuknya dan dikaitkan dengan objek itu. Di sisi lain, setiap utas yang dibuat dengan mengimplementasikan antarmuka Runnable berbagi instance runnable yang sama.
- Karena setiap utas dikaitkan dengan objek unik ketika dibuat dengan memperluas kelas Utas, diperlukan lebih banyak memori. Di sisi lain, setiap utas yang dibuat dengan mengimplementasikan antarmuka Runnable berbagi ruang objek yang sama sehingga membutuhkan lebih sedikit memori.
- Jika Anda memperluas kelas Thread lebih jauh, Anda bisa mewarisi kelas lain karena Java tidak mengizinkan banyak pewarisan, sedangkan penerapan Runnable masih memberikan kesempatan bagi kelas untuk mewarisi kelas lain.
- Seseorang harus memperluas kelas Thread hanya jika harus menimpa atau mengkhususkan beberapa metode lain dari kelas Thread. Anda harus mengimplementasikan antarmuka Runnable jika Anda hanya ingin mengkhususkan metode yang dijalankan saja.
- Memperluas kelas Thread memperkenalkan kopling ketat dalam kode karena kode Thread dan pekerjaan thread dikandung oleh kelas yang sama. Di sisi lain, antarmuka Implementing Runnable memperkenalkan kopling longgar dalam kode karena kode Thread dipisahkan dari pekerjaan yang ditetapkan ke utas.
Kesimpulan:
Lebih disukai untuk mengimplementasikan antarmuka Runnable daripada memperluas kelas Thread. Saat menerapkan Runnable, buat kode Anda secara longgar digabungkan karena kode utas berbeda dari kelas yang memberikan tugas pada utas. Ini membutuhkan lebih sedikit memori dan juga memungkinkan kelas untuk mewarisi kelas lain.
