1. Konsep dasar utas
Pemahaman Thread: Thread adalah jalur eksekusi yang berbeda dalam suatu program
Setiap cabang disebut utas, dan main () disebut cabang utama, juga disebut utas utama.
Suatu proses hanyalah konsep statis, file .class pada mesin, file .exe pada mesin, ini disebut proses. Proses eksekusi program seperti ini: Pertama, masukkan kode program ke dalam area kode memori. Setelah kode ditempatkan di area kode, ia tidak segera mulai mengeksekusi. Namun, ini berarti suatu proses siap untuk dimulai. Prosesnya telah dihasilkan, tetapi belum mulai mengeksekusi. Ini adalah prosesnya, jadi prosesnya sebenarnya adalah konsep statis dan tidak dapat dipindahkan dengan sendirinya. Eksekusi proses yang biasa mengacu pada utas utama dalam proses yang mulai mengeksekusi, yaitu metode utama () mulai dieksekusi. Proses adalah konsep statis, dan sebenarnya utas yang dijalankan di mesin kami.
Sistem operasi Windows mendukung multi-threading. Ini dapat mengeksekusi banyak utas secara bersamaan dan juga mendukung banyak proses. Oleh karena itu, sistem operasi Windows adalah sistem operasi yang mendukung multi-threading dan multi-pemrosesan. Linux dan Uinux juga merupakan sistem operasi yang mendukung multi-threading dan multi-pemrosesan. DOS tidak mendukung multi-threading dan multi-pemrosesan. Ini hanya mendukung proses tunggal. Hanya satu proses yang dieksekusi pada titik waktu yang sama, yang disebut single-threading.
Apakah CPU benar -benar kuat dan mampu menjalankan begitu banyak program secara bersamaan? Tidak, eksekusi CPU adalah sebagai berikut: CPU sangat cepat, dan dapat dihitung ratusan juta kali dalam satu detik, sehingga CPU membagi waktunya menjadi irisan waktu kecil. Saya mengeksekusi waktu ini untuk sementara waktu, saat berikutnya Slice akan menjalankannya untuk sementara waktu, dan selanjutnya Slice akan mengeksekusi orang lain untuk sementara waktu. Meskipun ada lusinan benang, mereka dapat dieksekusi semuanya dalam waktu yang sangat singkat. Tetapi bagi kita manusia, kecepatan eksekusi CPU terlalu cepat, jadi sepertinya sedang dieksekusi pada saat yang sama, tetapi pada kenyataannya, pada titik waktu, hanya ada satu utas yang berjalan di CPU.
Pertama -tama, Anda perlu memahami tiga konsep saat belajar utas :
1. Proses: Proses adalah konsep statis
2. Thread: Ada utas utama dalam proses yang disebut metode main (), yang merupakan program dan jalur eksekusi yang berbeda dalam suatu proses.
3. Pada saat yang sama, CPU hanya dapat mendukung satu utas untuk dieksekusi. Karena CPU berjalan sangat cepat, kami terlihat seperti kami multithreading.
Apa itu multithreading sejati? Jika mesin Anda memiliki CPU ganda atau inti ganda, itu memang multi-threaded.
2. Kreasi dan startup utas
Di Java, utas Java diimplementasikan melalui kelas java.lang.thread, dan setiap objek utas mewakili utas baru. Ada dua cara untuk membuat utas baru: yang pertama adalah mewarisi dari kelas utas, dan yang lainnya adalah mengimplementasikan antarmuka yang dapat dijalankan. Ketika VM dimulai, akan ada utas yang ditentukan oleh metode utama (public static void main ()), dan utas ini disebut utas utama. Utas baru dapat dibuat dengan membuat instance utas. Anda hanya perlu objek utas baru, dan utas baru akan muncul. Setiap utas menyelesaikan operasinya melalui metode run () yang sesuai dengan objek utas tertentu. Metode run () disebut bodi utas.
Contoh 1: Buat dan mulai utas baru menggunakan implementasi antarmuka runnable
Buat utas baru untuk memanggil metode jalankan
Paket cn.galc.test; kelas publik testThread1 {public static void main (string args []) {runner1 r1 = runner1 baru (); // Di sini objek baru dari kelas utas keluar // r1.run (); // ini disebut panggilan metode. Eksekusi panggilan metode adalah untuk menunggu sampai metode run () dieksekusi sebelum metode main () akan terus dijalankan. Thread t = Thread baru (r1); // Untuk memulai utas baru, Anda harus keluar dari utas baru // thread (target runnable) digunakan di sini. Konstruktor t.start (); // Mulai utas yang baru dibuka, utas baru mengeksekusi metode run (), dan utas baru dan utas utama akan dieksekusi secara paralel untuk (int i = 0; i <10; i ++) {System.out.println ("Maintheod:"+i); }}}/*Tentukan kelas untuk mengimplementasikan antarmuka Runnable. Menerapkan antarmuka runnable berarti bahwa kelas ini adalah kelas utas*/class runner1 mengimplementasikan runnable {public void run () {for (int i = 0; i <10; i ++) {System.out.println ("runner1:"+i); }}}Proses eksekusi program multi-threaded adalah sebagai berikut:
Hubungi metode run secara langsung tanpa membuka utas baru
Hasil operasi adalah sebagai berikut:
Contoh 2: Mewariskan kelas utas dan mengganti metode run () untuk membuat dan memulai utas baru
Paket cn.galc.test;/*Metode kedua pembuatan utas dan startup: Tentukan subkelas utas dan mengimplementasikan metode run ()*/kelas publik testThread2 {public static void main (string args []) {runner2 r2 = new runner2 (); r2.start (); // Panggil metode start () untuk memulai utas yang baru dibuka untuk (int i = 0; i <= 10; i ++) {System.out.println ("MainMethod:"+i); }}}/*Runner2 kelas mewarisi dari kelas utas dengan instantiating objek kelas runner2, Anda dapat membuka utas baru. Hubungi metode start () yang diwarisi dari kelas utas. Anda dapat memulai utas yang baru dibuka*/class runner2 memperluas utas {public void run () {// tulis ulang implementasi metode run () untuk (int i = 0; i <= 10; i ++) {System.out.println ("runner2:"+i); }}}Pilihan menggunakan dua metode untuk membuat utas baru, yaitu menerapkan antarmuka yang dapat dilalui dan mewarisi kelas utas, harus diberikan prioritas untuk membuka utas baru. Karena implementasi suatu antarmuka dapat mengimplementasikan beberapa, warisan kelas hanya dapat berupa warisan tunggal. Oleh karena itu, ketika Anda dapat menggunakan antarmuka Runnable saat membuka utas baru, cobalah untuk tidak menggunakan warisan dari kelas utas untuk membuka utas baru.
3. Transisi Negara Benang
3.1. Metode dasar kontrol utas
3.2. Pengantar metode tidur/gabungan/hasil
Contoh penerapan metode tidur:
Paket cn.galc.test; import java.util.*; kelas publik testthread3 {public static void main (string args []) {mythread thread = myThread baru (); thread.start (); // hubungi metode start () untuk memulai utas yang baru dibuka coba {/*Thread.sleep(10000); Metode sleep () adalah metode statis yang dinyatakan di kelas utas, sehingga Anda dapat menggunakan format thread.sleep () untuk memanggil * / /*mythread.sleep(10000); Kelas MyThread mewarisi kelas utas dan secara alami juga mewarisi metode tidur (), sehingga Anda juga dapat menyebutnya menggunakan format mythread.sleep () *// *Panggilan metode statis dapat secara langsung disebut dalam bentuk "Nama Metode Kelas" atau "Referensi Objek. Nama Metode Statis" */ MyThread.sleep (10000); System.out.println ("Thread utama tidur selama 10 detik dan mulai lagi"); // Saat memanggil metode statis kelas lain dalam metode main (), Anda perlu menggunakan nama "class.static Metode di mana metode statis berada" metode untuk menelepon /* jadi di sini adalah membiarkan utas utama tidur selama 10 detik. Metode utas mana yang disebut sleep (), jadi sekarang utas utama tidur. */} catch (InterruptedException e) {E.PrintStackTrace (); } //thread.interrupt();//use interrupt () Metode untuk mengakhiri eksekusi thread thread.flag = false; // Ubah kondisi loop dan akhiri loop mati/** * Ketika interruptException terjadi, langsung mengatur kondisi loop ke false untuk keluar dari loop dead, * lalu mengakhiri eksekusi utas anak. Ini adalah cara yang lebih baik untuk mengakhiri benang anak* / / *** Metode Calling Interrupt () untuk memecahkan utas yang berjalan setara dengan menuangkan panci air dingin di benang utama dan memecahkan sub-utas yang mengeksekusi. Setelah sub-thread yang dieksekusi terputus, ExterruptedException akan dilemparkan, yang akan mengeksekusi pernyataan pengembalian dan mengakhiri eksekusi utas. So the sub-thread here ends the execution of the thread after 10 seconds of execution*/ }}class MyThread extends Thread { boolean flag = true;// Define a tag to control the conditions of the loop public void run() { /* * Note: Here, you cannot write throw Exception directly behind the run() method to throw exceptions, * Because now we need to rewrite the run() method inherited from the Thread class, the rewrite method cannot throw pengecualian berbeda dari metode penulisan ulang. * Jadi di sini Anda hanya bisa menulis mencoba ... catch () untuk menangkap pengecualian*/ while (flag) { System.out.println ("======================================================================================================================================== ================================================================= ================================================================= ================================================================= ================================================================= ================================================================= ================================================================== Tentu saja, tidak salah untuk menyebutnya menggunakan format "nama kelas. Metode nama"*// mythread.sleep (1000); // Gunakan format "nama kelas. Nama metode" untuk menyebutkan Metode Static Sleep (1000); // jika ada di sini, dan di sini, dan di sini, dan di sini akan dibuka di sini. Dimulai setiap detik dalam loop mati, dan waktu sistem saat ini dicetak setiap detik} tangkapan (interruptedException e) { /** Ketika tidur, pelat air dingin dapat mengganggu tidur* Oleh karena itu, ketika utas yang berjalan terganggu oleh beberapa alasan yang tidak terduga, yang dikembalikan, yang dikembalikan, yang dikembalikan / pengembalian yang diinterupsi; }}}Hasil Menjalankan:
Contoh metode gabungan:
paket cn.galc.test; kelas publik testThread4 {public static void main (string args []) {myThread2 thread2 = myThread2 baru ("mythread"); // Saat membuat objek utas baru, beri nama objek utas mythread thread2.start (); // Mulai utas coba {thread2.join (); // Panggil metode gabungan () untuk menggabungkan utas, menggabungkan utas anak ke utas utama // setelah menggabungkan utas, proses eksekusi program ini setara dengan proses eksekusi dari proses eksekusi} call call} Method Call (Method Call Call (Method Calling (Method Calling. } untuk (int i = 0; i <= 5; i ++) {System.out.println ("Saya utas utama"); }}} kelas myThread2 memperluas utas {myThread2 (string s) {super (s); / * * Gunakan kata kunci super untuk memanggil konstruktor kelas induk * salah satu konstruktor dari utas kelas induk: "utas publik (nama string)" * Melalui konstruktor seperti itu, utas yang baru dibuka dapat disebutkan namanya, yang memfasilitasi manajemen utas */} public run () {for (int i = 1; i <= 5; i ++) {"wn. // gunakan // string akhir publik getName () yang ditentukan dalam utas kelas induk, mengembalikan nama utas ini. coba {sleep (1000); // buat benang anak tidur selama 1 detik setiap kali dieksekusi} catch (interruptedException e) {return; }}}}Hasil Menjalankan:
Contoh Penggunaan Metode Hasil:
paket cn.galc.test; kelas publik testThread5 {public static void main (string args []) {myThread3 t1 = myThread3 baru ("t1"); /* Dua benang anak T1 dan T2 dibuka pada saat yang sama. T1 dan T2 keduanya mengeksekusi metode run ()*//*Ada total 3 utas secara paralel selama pelaksanaan program ini, yaitu benang anak T1 dan T2 dan utas utama*/ mythread3 t2 = mythread3 baru ("t2"); t1.start (); // starter anak utas t1 t2.start (); // starter anak utas t2 untuk (int i = 0; i <= 5; i ++) {System.out.println ("Saya utas utama"); }}} kelas myThread3 memperluas utas {myThread3 (string s) {super (s); } public void run () {for (int i = 1; i <= 5; i ++) {System.out.println (getName () + ":" + i); if (i % 2 == 0) { yield();// When the execution reaches i can be divided by 2, the current thread executing is given out and let another thread executing the run() method be executed first/* * You can see during the running of the program, * When thread t1 is executed (i%2==0) times, it will give out the thread and let the t2 thread execute first*, and when thread t2 is executed (i%2 == 0) kali, itu akan memberikan utas ke utas T1 ke eksekusi prioritas */}}}Hasil operasi adalah sebagai berikut:
Di atas adalah semua konten artikel ini. Kami berharap ini dapat membantu Anda.