Marilah kita perhatikan beberapa perbezaan antara Thread dan Runnable dengan bantuan carta perbandingan yang ditunjukkan di bawah:
Carta Perbandingan
| Asas untuk Perbandingan | Thread | Runnable |
|---|---|---|
| Asas | Setiap benang mencipta objek unik dan dikaitkan dengannya. | Pelbagai thread berkongsi objek yang sama. |
| Memori | Oleh kerana setiap benang membuat objek yang unik, memori lebih diperlukan. | Oleh kerana pelbagai thread berkongsi objek yang sama memori kurang digunakan. |
| Memperluas | Di Jawa, pelbagai pusaka tidak dibenarkan oleh itu, selepas kelas memanjangkan kelas Thread, ia tidak dapat melanjutkan kelas apa pun. | Sekiranya kelas menentukan thread yang melaksanakan antara muka Runnable, ia mempunyai peluang untuk memperluaskan satu kelas. |
| Guna | Seorang pengguna mesti melanjutkan kelas thread hanya jika ia mahu mengatasi kaedah lain dalam kelas Thread. | Sekiranya anda hanya ingin memperkenalkan kaedah run maka pelaksanaan Runnable adalah pilihan yang lebih baik. |
| Gandingan | Memperluas kelas Thread memperkenalkan gandingan yang ketat kerana kelas mengandungi kod kelas Thread dan juga tugas yang diberikan kepada benang | Melaksanakan antaramuka Runnable memperkenalkan gandingan longgar sebagai kod Thread adalah bentuk berasingan kerja Thread. |
Definisi Kelas Thread
Thread adalah kelas dalam pakej java.lang . Kelas Thread memperluaskan kelas Objek, dan ia melaksanakan antara muka Runnable . Kelas Thread mempunyai konstruktor dan kaedah untuk membuat dan mengendalikan thread. Apabila kita membuat pelbagai thread, setiap benang menghasilkan objek yang unik dan dapat dikaitkan dengan objek tersebut. Sekiranya anda membuat thread yang memanjangkan kelas Thread, anda tidak boleh melanjutkan kelas lain sebagai java tidak menyokong banyak pusaka. Oleh itu, anda perlu memilih untuk melanjutkan kelas Thread sahaja apabila anda juga mahu mengatasi beberapa kaedah Thread kelas yang lain. Marilah kita melihat contoh membuat thread melanjutkan kelas Thread.
/ * Menentukan thread * / Kelas Mythread memanjangkan Thread {/ * kerja thread * / public void run () {untuk (int i = 0; i <10; i ++) {System.Out.Println ("Thread Anak" ); }} Kelas mainThread {/ * kerja benang utama * / public static void main (String args []) {Mythread mt = Mythread baru (); / * thread utama mencipta benang anak * / mt.start (); untuk (int i = 0; i <10; i ++) {System.Out.Print ("Thread Utama"); }}}}}}}}}}}}}}}}}}}}}} /} Output * / Utas Utama Main Thread Utas Main Thread Utas Anak Thread Utas Anak Thread Utas Anak Thread Utas Main Thread Utas Anak Thread Utama Utas Main Thread Anak Thread Utas Main Thread Utas Anak Thread Anak Thread Thread Utama Dalam kod di atas, saya membuat kelas Mythread yang memanjangkan kelas Thread dan mengatasi kaedah run kelas Thread. Dalam kelas yang mengandungi kaedah utama saya membuat objek thread (mt) kelas Mythread dan menggunakan objek thread yang menggunakan kaedah start (). Kaedah permulaan bermula pelaksanaan thread dan pada masa yang sama JVM memanggil kaedah run thread. Sekarang terdapat dua benang dalam program satu benang utama dan benang anak kedua yang dibuat oleh benang utama. Pelaksanaan kedua-dua benang berlaku serentak, tetapi, output yang tepat tidak boleh berpura-pura.
Definisi Antara Muka yang Boleh Dikendalikan
Runnable adalah antara muka dalam pakej java.lang . Melaksanakan antara muka Runnable kita boleh menentukan thread. Antara muka yang boleh dilancarkan mempunyai satu kaedah yang dijalankan (), yang dilaksanakan oleh kelas yang melaksanakan antara muka Runnable. Apabila anda memilih untuk menentukan thread yang melaksanakan antara muka Runnable anda masih mempunyai pilihan untuk melanjutkan kelas lain. Apabila anda membuat pelbagai thread dengan melaksanakan antara muka Runnable, setiap thread berkongsi contoh runnable yang sama. marilah kita belajar cara menentukan thread menggunakan antara muka Runnable.
/ * Menetapkan thread * / Kelas Runnablethread mengimplementasikan Runnable {/ * kerja thread * / public void run () {untuk (int i = 0; i <10; i ++) {System.Out.Println ("Thread Anak" ); }} Kelas mainThread {/ * kerja benang utama * / public static void main (String args []) {Mythread rt = Mythread baru (); / * thread utama mencipta objek runnable * / Thread t = Thread baru (rt); / * benang utama mencipta benang anak dan lulus objek runnable * / t.start (); untuk (int i = 0; i <10; i ++) {System.Out.Print ("Thread Utama"); }}}}}}}}}}}}}}}}}}}}}} /} Output * / Utas Utama Main Thread Utas Main Thread Utas Anak Thread Utas Anak Thread Utas Anak Thread Utas Main Thread Utas Anak Thread Utama Utas Main Thread Anak Thread Utas Main Thread Utas Anak Thread Anak Thread Thread Utama Dalam kod di atas, saya mencipta Runnablethread kelas yang melaksanakan antara muka Runnable dan mentakrifkan kerja thread dengan melaksanakan run () kaedah antara muka Runnable. Kemudian saya membuat kelas utama yang mengandungi kaedah utama. Di dalam kaedah utama, saya mengisytiharkan objek runnable kelas Runnablethread dan lulus objek ini ke pembina Thread semasa mengisytiharkan thread. Dengan cara ini, saya menghubungkan objek thread (t) dengan objek runnable (rt). Kemudian objek thread memanggil kaedah permulaan benang yang selanjutnya memanggil kaedah menjalankan kelas Runnablethread. Sekiranya saya tidak memautkan objek runnable dengan objek Thread, maka kaedah mula thread akan menggunakan kaedah run Thread kelas. Sekarang, sekali lagi terdapat dua benang dalam kod, benang utama dan benang utama menciptakan benang anak kedua dapat dilaksanakan secara bersamaan tetapi output yang tepat tidak akan pernah berpura-pura.
Perbezaan Utama antara Thread dan Runnable di Jawa
- Setiap benang yang dibuat dengan memperluas kelas Thread mewujudkan objek yang unik untuknya dan dikaitkan dengan objek itu. Sebaliknya, setiap benang yang dihasilkan dengan melaksanakan antara muka Runnable berkongsi contoh runnable yang sama.
- Oleh kerana setiap thread dikaitkan dengan objek yang unik apabila dicipta dengan memperluaskan kelas Thread, lebih banyak memori diperlukan. Sebaliknya, setiap benang yang dihasilkan dengan melaksanakan antara muka Runnable berkongsi objek objek yang sama dengan itu, ia memerlukan memori yang kurang.
- Sekiranya anda memperluaskan kelas Thread kemudian, anda boleh mewarisi mana-mana kelas lain sebagai Java tidak membenarkan warisan berganda sedangkan, melaksanakan Runnable masih memberikan peluang untuk kelas mewarisi mana-mana kelas lain.
- Seseorang mesti melanjutkan kelas Thread hanya jika ia perlu menimpa atau mengkhususkan beberapa kaedah lain kelas Thread. Anda mesti melaksanakan antara muka Runnable jika anda hanya ingin mengesyorkan kaedah larian sahaja.
- Memperluas kelas Thread memperkenalkan gandingan yang ketat dalam kod sebagai kod Benang dan kerja benang terkandung oleh kelas yang sama. Sebaliknya, Melaksanakan antara muka Runnable memperkenalkan gandingan longgar dalam kod itu kerana kod Thread adalah sepintas dari tugas yang diberikan kepada thread.
Kesimpulan:
Lebih disukai untuk melaksanakan antara muka Runnable dan bukannya memperluaskan kelas Thread. Sebagai melaksanakan Runnable membuat kod anda dilepaskan dengan longgar sebagai kod benang adalah berbeza dari kelas yang memberikan tugas ke thread. Ia memerlukan memori yang kurang dan juga membolehkan kelas mewarisi mana-mana kelas yang lain.
