Utas perbandingan utas java, runnable, callable
Java menggunakan kelas utas untuk mewakili utas, dan semua objek bidang harus menjadi contoh kelas utas atau subkelasnya. Fungsi masing -masing utas adalah menyelesaikan tugas tertentu, yang sebenarnya untuk menjalankan aliran program. Java menggunakan badan eksekusi utas untuk mewakili aliran program ini.
1. Mewariskan kelas utas untuk membuat utas
Langkah -langkah untuk memulai multithreading adalah sebagai berikut:
(1) Tentukan subclass dari kelas utas dan override metode run () dari kelas. Badan metode dari metode run () mewakili tugas yang perlu diselesaikan oleh utas kelas. Oleh karena itu, metode run () disebut badan eksekusi utas.
(2) Buat instance subkelas utas, yaitu, buat objek utas.
(3) Hubungi metode bintang utas () untuk memulai utas.
Kode yang relevan adalah sebagai berikut:
/ *** mewarisi kelas bagian dalam utas untuk membeli tiket misalnya*/ kelas publik FirstThread memperluas utas {private int i; tiket int pribadi = 10; @Override public void run () {for (; i <20; i ++) {// Saat mewarisi utas, gunakan ini secara langsung untuk mendapatkan utas saat ini, getName () Dapatkan nama utas saat ini // log.d (tag, getName ()+""+i); if (this.ticket> 0) {log.e (tag, getName () + ", penjualan tiket: tiket =" + tiket--); }}}} private void starticketThread () {log.d (tag, "starticketThread,"+thread.currentThread (). getName ()); Firstthread thread1 = firsttread baru (); Firstthread thread2 = firsttread baru (); Firstthread thread3 = firsttread baru (); thread1.start (); thread2.start (); thread3.start (); // Buka 3 utas untuk membeli tiket, setiap utas menjual 10 tiket, dan total 30 tiket}Hasil Menjalankan:
Anda dapat melihat bahwa variabel suara yang dimasukkan oleh 3 utas tidak berkelanjutan. Catatan: Tiket adalah properti instan dari FirstThread, bukan variabel lokal, tetapi karena program perlu membuat objek FirstThread setiap kali membuat objek utas, semua utas tidak berbagi atribut instance.
2. Menerapkan antarmuka runnable untuk membuat utas
Catatan: Utas kelas publik mengimplementasikan Runnable
(1) Tentukan kelas implementasi dari antarmuka yang dapat dijalankan dan mengesampingkan metode run () dari antarmuka. Metode Badan dari Metode Run () juga merupakan badan eksekusi utas utas.
(2) Buat instance dari kelas instance runnable. Contoh ini digunakan sebagai target utas untuk membuat objek utas. Objek utas adalah objek nyata.
Kode yang relevan adalah sebagai berikut:
/ ** * Menerapkan antarmuka runnable dan membuat kelas utas */ kelas publik SecondThread mengimplementasikan runnable {private int i; Tiket int pribadi = 100; @Override public void run () {for (; i <20; i ++) {// Jika kelas utas mengimplementasikan antarmuka runnable // dapatkan utas saat ini, Anda hanya dapat menggunakan thread.currentThread () untuk mendapatkan nama utas saat ini (tag, thread.currentThread (). GetName ()+"+i); if (this.ticket> 0) {log.e (tag, thread.currentThread (). getName () + ", penjualan tiket: tiket =" + tiket--); }}}} private void startIcketThread2 () {log.d (tag, "starticketThread2,"+thread.currentThread (). getName ()); SecondThread SecondThread = new SecondThread (); // Buat utas baru melalui utas baru (target, nama) utas baru (SecondThread, "Tiket Pembeli 1"). Start (); utas baru (SecondThread, "Pembeli Tiket 2"). Start (); utas baru (SecondThread, "Pembeli Tiket 3"). Start (); // Meskipun 3 utas dibuka, hanya 100 tiket yang dibeli secara total}Hasil Menjalankan:
Anda dapat melihat bahwa variabel suara yang dimasukkan oleh 3 utas kontinu, dan banyak utas dapat berbagi properti dari instance kelas utas menggunakan antarmuka runnable. Ini karena dengan cara ini, objek runnable yang dibuat oleh program hanyalah target utas, dan banyak utas dapat berbagi target yang sama, sehingga banyak utas dapat berbagi properti instan dari kelas utas yang sama (yang sebenarnya harus menjadi kelas target utas).
3. Buat utas menggunakan Callable dan Future
Mulai dari Java 5, Java menyediakan antarmuka yang dapat dipanggil, yang merupakan versi yang ditingkatkan dari Runnable. Callable menyediakan metode kelas yang dipanggil () yang dapat digunakan sebagai badan eksekusi utas, tetapi metode call () lebih kuat.
(1) Metode panggilan () dapat memiliki nilai pengembalian (2) metode panggilan () dapat menyatakan pengecualian yang dilemparkan
Oleh karena itu, kami dapat memberikan objek yang dapat dipanggil sebagai target utas, dan pelaksana utas adalah metode panggilan () dari objek yang dapat dipanggil. Pada saat yang sama, Java 5 menyediakan antarmuka di masa depan untuk mewakili nilai pengembalian metode Call () di antarmuka yang dapat dipanggil, dan menyediakan kelas implementasi Futuretask. Kelas implementasi ini mengimplementasikan antarmuka di masa depan dan mengimplementasikan antarmuka yang dapat dijalankan - target yang dapat digunakan sebagai kelas utas.
Langkah startup adalah sebagai berikut:
(1) Buat kelas implementasi antarmuka yang dapat dipanggil dan mengimplementasikan metode Call (). Metode Call () akan digunakan sebagai badan eksekusi utas, dan metode Call () memiliki nilai pengembalian.
(2) Buat instance dari kelas implementasi yang dapat dipanggil dan gunakan kelas Futuretask untuk membungkus objek yang dapat dipanggil. Objek Futuretask merangkum nilai pengembalian metode panggilan ().
(3) Buat dan mulai utas baru menggunakan objek Futuretask sebagai target objek utas.
(4) Panggil metode GET () dari objek Futuretask untuk mendapatkan nilai pengembalian setelah utas anak dieksekusi.
Kode yang relevan adalah sebagai berikut:
/ *** Gunakan Callable untuk mengimplementasikan kelas utas*/ kelas publik ketiga yang dapat diterapkan Callable <Integer> {private int ticket = 20; @Override Public Integer Call () {for (int i = 0; i <10; i ++) {// Dapatkan utas saat ini, Anda hanya dapat menggunakan thread.currentThread () untuk mendapatkan nama utas saat ini // log.d (tag, thread.currentthread (). GetName ()+""+i); if (this.ticket> 0) {log.e (tag, thread.currentThread (). getName () + ", tiket: tiket =" + tiket--); }} return ticket; }} private void starcallableThread () {ketigatHread ketigathread = new ThirdThread (); Futuretask <Integer> Tugas = FutureTask baru <Integer> (ThirdThread); utas baru (tugas, "utas dengan nilai pengembalian"). start (); coba {integer integer = task.get (); Log.d (tag, "starcallablethread, nilai pengembalian thread anak ="+integer); } catch (InterruptedException e) {E.PrintStackTrace (); } catch (executionException e) {e.printstacktrace (); }}Hasil Menjalankan:
Catatan: Metode Callable's Call () memungkinkan deklarasi untuk melempar pengecualian dan memungkinkan untuk nilai pengembalian.
Program akhirnya memanggil metode GET () dari objek Futuretask untuk mengembalikan nilai pengembalian metode Call (), menyebabkan utas utama diblokir sampai metode Call () berakhir dan kembali.
4. Perbandingan tiga cara
Buat multi-threading dengan mewarisi kelas utas
Kerugian: Kelas utas telah diwarisi tidak dapat diwarisi dari kelas orang tua lainnya.
Keuntungan: mudah ditulis
Buat multi-threading menggunakan metode mewarisi antarmuka yang dapat di-runnable dan callable
Kerugian: Pemrograman agak rumit. Jika Anda perlu mengakses utas saat ini, Anda harus menggunakan thread.currentThread ()
Keuntungan:
(1) Ini juga dapat mewarisi kelas lain (2) beberapa utas dapat berbagi objek target, sehingga sangat cocok untuk beberapa utas yang identik untuk menangani sumber daya yang sama, sehingga memisahkan CPU, kode dan data untuk membentuk model yang jelas, yang lebih mencerminkan gagasan kelas yang berorientasi objek.
Terima kasih telah membaca, saya harap ini dapat membantu Anda. Terima kasih atas dukungan Anda untuk situs ini!