Baru-baru ini, saya belajar dan mempelajari penggunaan java multi-threading ketika melakukan optimasi kode, dan kemudian merangkumnya setelah membaca wawasan para novis.
1. Mewarahkan kelas utas untuk mengimplementasikan multi-threading
Meskipun metode yang mewarisi kelas utas terdaftar sebagai metode implementasi multi-thread, utas pada dasarnya adalah instance dari antarmuka runnable, yang mewakili instance dari utas, dan satu-satunya cara untuk memulai utas adalah melalui metode instance start () dari kelas utas. Metode Start () adalah metode asli yang akan memulai utas baru dan menjalankan metode run (). Metode ini sangat mudah diimplementasikan multi-threading. Dengan secara langsung memperluas utas melalui kelas Anda sendiri dan menulis ulang metode run (), Anda dapat memulai utas baru dan menjalankan metode run () yang Anda tentukan. Misalnya:
kelas publik MyThread memperluas utas {public void run () {System.out.println ("myThread.run ()"); }} Mulai utas di tempat yang tepat sebagai berikut:
Mythread mythread1 = mythread baru (); Mythread mythread2 = mythread baru (); myThread1.start (); mythread2.start ();
2. Menerapkan antarmuka runnable untuk mengimplementasikan multi-threading
Jika kelas Anda sudah memperluas kelas lain, Anda tidak dapat memperluas utas secara langsung. Saat ini, Anda harus menerapkan antarmuka yang dapat dijalankan, sebagai berikut:
MyThread kelas publik memperluas implementasi kelas lain yang dapat dijalankan {public void run () {System.out.println ("myThread.run ()"); }} Untuk memulai MyThread, Anda harus pertama -tama membuat instansi dan meneruskan instance MyThread Anda sendiri:
Mythread mythread = mythread baru (); Thread Thread = Thread Baru (MyThread); thread.start ();
Bahkan, ketika parameter target yang dapat dijalankan diteruskan ke utas, metode run () utas akan memanggil target.run (), lihat kode sumber JDK:
public void run () {if (target! = null) {target.run (); }} 3. Gunakan ExecutorService, Callable, dan Future untuk mencapai multi-threading dengan hasil pengembalian
Objek ExecutorService, Callable, dan Masa Depan sebenarnya adalah kelas fungsional dalam kerangka kerja pelaksana. Ini adalah penjelasan yang sangat rinci tentang kerangka kerja. Utas yang mengembalikan hasilnya adalah fitur baru yang diperkenalkan di JDK1.5. Memang sangat praktis. Dengan fitur ini, saya tidak perlu mengalami banyak masalah untuk mendapatkan nilai pengembalian, dan bahkan jika diterapkan, itu mungkin penuh dengan celah.
Tugas yang dapat mengembalikan nilai harus mengimplementasikan antarmuka yang dapat dipanggil, dan juga, tugas yang tidak mengembalikan nilai harus memiliki antarmuka yang dapat dijalankan. Setelah menjalankan tugas yang dapat dipanggil, Anda bisa mendapatkan objek di masa depan. Hubungi dapatkan objek untuk mendapatkan objek dikembalikan oleh tugas yang dapat dipanggil. Dikombinasikan dengan ExecutorService Antarmuka Pool Thread, Anda dapat menyadari multi-threading legendaris dengan hasil pengembalian. Di bawah ini adalah contoh pengujian multi-utas lengkap dengan hasil yang dikembalikan. Jika Anda telah memverifikasinya di bawah JDK1.5, Anda dapat menggunakannya secara langsung. Kodenya adalah sebagai berikut:
impor java.util.concurrent.*; impor java.util.date; impor java.util.list; impor java.util.arraylist; / *** Thread dengan nilai pengembalian*/ @suppresswarnings ("Uncecked") Tes kelas publik {public static void main (string [] args) melempar ExecutionException, InterruptedException { System.out.println ("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- = Executors.newfixedThreadPool (TaskSize); System.out.println (">>>" + f.get (). ToString ())); // Dapatkan hasil berjalan dari semua tugas bersamaan untuk (Future F: List) {// Dapatkan nilai pengembalian tugas dari objek mendatang dan output ke konsol System.out.println (">>>" + f.get (). ToString ()); } Tanggal Tanggal2 = Tanggal Baru (); System.out.println("----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- MyCallable (String Tasknum) {this.tasknum = Tasknum; DatetMP1.GetTime (); Deskripsi Kode:
Dalam kode di atas, kelas Executors menyediakan serangkaian metode pabrik untuk membuat kumpulan utas, dan kumpulan utas yang dikembalikan semuanya mengimplementasikan antarmuka ExecutorService.
Public Static ExecutorService newfixedthreadpool (int nthreads)
Membuat kumpulan utas dengan jumlah utas yang tetap.
Public Static ExecutorService newcachedthreadpool ()
Buat kumpulan utas yang dapat di -cache, Calling Execute akan menggunakan kembali utas yang dibangun sebelumnya (jika utasnya tersedia). Jika utas yang ada tidak tersedia, buat utas baru dan tambahkan ke kumpulan. Hentikan dan hapus utas dari cache yang belum digunakan selama 60 detik.
Public Static ExecutorService NewsingLetHreadExecutor ()
Buat eksekutor utamanya tunggal.
public static jadwal executorservice newscheduledthreadpool (int corepoolsize)
Buat kumpulan utas yang mendukung eksekusi tugas waktu dan berkala, yang dapat digunakan dalam kebanyakan kasus alih -alih kelas timer.
ExecutOreService menyediakan metode pengiriman (), melewati callable, atau runnable, dan returning future. Jika Executor Background Thread Pool belum menyelesaikan perhitungan yang dapat dipanggil, panggilan ini mengembalikan metode GET () dari objek masa depan, yang akan memblokir sampai perhitungan selesai.