Multithreading: Apakah kaedah kelas Thread lakukan

Hai! Hari ini kita akan terus bercakap tentang multithreading. Mari kita periksa kelas Thread dan apa yang dilakukan oleh beberapa kaedahnya. Apabila kami mempelajari kaedah kelas sebelum ini, kami biasanya hanya menulis ini: <nama kaedah> -> <apa yang dilakukan oleh kaedah>. Ini tidak akan berfungsi dengan Threadkaedah :) Mereka mempunyai logik yang lebih kompleks yang anda tidak akan dapat memikirkannya tanpa beberapa contoh.

Kaedah Thread.start().

Mari kita mulakan dengan mengulangi diri kita sendiri. Seperti yang anda mungkin ingat, anda boleh mencipta urutan dengan menjadikan kelas anda mewarisi kelas Threaddan mengatasi run()kaedah tersebut. Tetapi ia tidak akan bermula dengan sendirinya, sudah tentu. Untuk melakukan ini, kami memanggil kaedah objek kami start(). Mari kita ingat contoh dari pelajaran sebelumnya:

public class MyFirstThread extends Thread {

   @Override
   public void run() {
       System.out.println("Thread executed: " + getName());
   }
}


public class Main {

   public static void main(String[] args) {

       for (int i = 0; i < 10; i++) {
           MyFirstThread thread = new MyFirstThread();
           thread.start();
       }
   }
}

Nota: Untuk memulakan utas, anda mesti memanggilstart()kaedah khas dan bukannyarun()kaedah! Ini adalah ralat yang mudah dibuat, terutamanya apabila anda mula belajar multithreading. Dalam contoh kami, jika anda memanggilrun()kaedah 10 kali dan bukannyastart(), anda akan mendapat ini:

public class Main {

   public static void main(String[] args) {

       for (int i = 0; i < 10; i++) {
           MyFirstThread thread = new MyFirstThread();
           thread.run();
       }
   }
}

Lihat hasil program kami: Thread dilaksanakan: Thread-0 Thread dilaksanakan: Thread-1 Thread dilaksanakan: Thread-2 Thread dilaksanakan: Thread-3 Thread dilaksanakan: Thread-4 Thread dilaksanakan: Thread-5 Thread dilaksanakan: Thread-6 Thread dilaksanakan: Thread-7 Thread dilaksanakan: Thread-8 Thread dilaksanakan: Thread-9 Lihat susunan output: Semuanya berlaku dalam susunan yang sempurna. Pelik, ya? Kami tidak biasa dengan ini, kerana kami sudah tahu bahawa urutan urutan dimulakan dan dilaksanakan ditentukan oleh intelek yang unggul dalam sistem pengendalian kami: penjadual benang. Mungkin kita hanya bertuah? Sudah tentu, ini bukan tentang nasib. Anda boleh mengesahkan ini dengan menjalankan program beberapa kali lagi. Isunya ialah panggilan iturun()kaedah secara langsung tidak ada kaitan dengan multithreading. Dalam kes ini, program akan dilaksanakan pada utas utama, utas yang sama yang melaksanakan main()kaedah. Ia hanya mencetak 10 baris berturut-turut pada konsol dan itu sahaja. 10 utas belum dimulakan. Jadi, ingat ini pada masa hadapan dan sentiasa periksa diri anda. Jika anda mahu run()kaedah dipanggil, hubungi start(). Mari pergi lebih jauh.

Kaedah Thread.sleep().

Untuk menggantung pelaksanaan utas semasa buat sementara waktu, kami menggunakan sleep()kaedah tersebut. Kaedah ini sleep()mengambil beberapa milisaat sebagai hujah, yang menunjukkan jumlah masa untuk meletakkan benang tidur.

public class Main {

   public static void main(String[] args) throws InterruptedException {

       long start = System.currentTimeMillis();

       Thread.sleep(3000);

       System.out.println(" - How long did I sleep? \n - " + ((System.currentTimeMillis()-start)) / 1000 + " seconds");

   }
}

Output konsol: - Berapa lama saya tidur? - 3 saat Nota: kaedah sleep()adalah statik: ia tidur benang semasa. Iaitu, yang sedang dilaksanakan. Berikut ialah satu lagi perkara penting: benang tidur boleh diganggu. Dalam kes ini, program membuang InterruptedException. Kami akan mempertimbangkan contoh di bawah. By the way, apa yang berlaku selepas benang bangun? Adakah ia akan terus dilaksanakan terus dari tempat ia berhenti? Tidak. Selepas benang terjaga, iaitu masa berlalu sebagai hujah telah Thread.sleep()berlalu, ia beralih kepada runnablenegeri. Tetapi, ini tidak bermakna bahawa penjadual benang akan menjalankannya. Ia berkemungkinan besar memberi keutamaan kepada beberapa utas tidak tidur yang lain dan membenarkan utas kami yang baru dibangunkan untuk meneruskan kerjanya sedikit kemudian. Pastikan anda ingat ini: bangun tidur tidak bermakna teruskan kerja dengan segera!

Kaedah Thread.join().

Kaedah ini join()menangguhkan pelaksanaan utas semasa sehingga utas lain selesai. Jika kita mempunyai 2 utas, t1dan t2, dan kita tulis

t1.join()

maka t2tidak akan bermula sehingga t1selesai kerjanya. Kaedah ini join()boleh digunakan untuk menjamin susunan pelaksanaan benang. Mari kita pertimbangkan bagaimana join()kaedah berfungsi dalam contoh berikut:

public class ThreadExample extends Thread {

   @Override
   public void run() {

       System.out.println("Thread started: " + getName());

       try {
           Thread.sleep(5000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       System.out.println("Thread " + getName() + " is finished.");
   }
}


public class Main {

   public static void main(String[] args) throws InterruptedException {

       ThreadExample t1 = new ThreadExample();
       ThreadExample t2 = new ThreadExample();

       t1.start();


 /* The second thread (t2) will start running only after the first thread (t1)
       is finished (or an exception is thrown) */
       try {
           t1.join();
       } catch (InterruptedException e) {
           e.printStackTrace();
       }

       t2.start();

       // The main thread will continue running only after t1 and t2 have finished
       try {
           t1.join();
           t2.join();
       } catch (InterruptedException e) {
           e.printStackTrace();
       }

       System.out.println("All threads have finished. The program is finished.");

   }
}

Kami mencipta ThreadExamplekelas yang mudah. Tugasnya adalah untuk memaparkan mesej bahawa utas telah dimulakan, tertidur selama 5 saat, dan kemudian akhirnya melaporkan bahawa kerja telah selesai. Sangat mudah. Logik utama adalah dalam Mainkelas. Lihat ulasan: kami menggunakan join()kaedah untuk berjaya menguruskan perintah pelaksanaan benang. Jika anda masih ingat bagaimana kami memulakan topik ini, perintah pelaksanaan dikendalikan oleh penjadual benang. Ia menjalankan benang mengikut budi bicaranya sendiri: setiap kali dengan cara yang berbeza. Di sini kami menggunakan kaedah untuk menjamin bahawa t1utas akan dimulakan dan dilaksanakan terlebih dahulu, kemudiant2utas, dan hanya selepas itu utas utama program akan diteruskan. Bergerak. Dalam program sebenar, anda akan sering menemui situasi apabila anda perlu mengganggu pelaksanaan utas. Sebagai contoh, utas kami sedang berjalan, tetapi ia sedang menunggu acara atau syarat tertentu. Jika ia berlaku, maka benang berhenti. Ia mungkin masuk akal jika terdapat beberapa jenis stop()kaedah. Tetapi ia tidak begitu mudah. Pada suatu masa dahulu, Java sebenarnya mempunyai Thread.stop()kaedah dan membenarkan benang diganggu. Tetapi ia kemudian dialih keluar dari perpustakaan Java. Anda boleh menemuinya dalam dokumentasi Oracle dan melihat bahawa ia ditandakan sebagai tidak digunakan lagi. kenapa? Kerana ia hanya menghentikan benang tanpa melakukan apa-apa lagi. Sebagai contoh, urutan mungkin berfungsi dengan data dan mengubah sesuatu. Kemudian di tengah-tengah kerjanya ia secara tiba-tiba dan tidak sengaja dipotong oleh stop()kaedah itu. Tanpa penutupan yang betul, mahupun pelepasan sumber, bahkan pengendalian ralat — tidak ada semua ini. Untuk membesar-besarkan sedikit, stop()kaedah itu hanya memusnahkan segala-galanya dengan caranya. Ia seperti menarik kord kuasa dari soket untuk mematikan komputer. Ya, anda boleh mendapatkan hasil yang diinginkan. Tetapi semua orang tahu bahawa selepas beberapa minggu komputer tidak akan berterima kasih kepada anda kerana memperlakukannya seperti itu. Itulah sebabnya logik untuk mengganggu benang berubah di Jawa dan kini menggunakan interrupt()kaedah khas.

Kaedah Thread.interrupt().

Apa yang berlaku jika interrupt()kaedah dipanggil pada benang? Terdapat 2 kemungkinan:

1. Jika objek berada dalam keadaan menunggu, contohnya, disebabkan kaedah joinatau sleep, maka penantian akan terganggu dan program akan membuang InterruptedException.
2. Jika benang berada dalam keadaan berfungsi, maka interruptedbendera boolean akan ditetapkan pada objek.

Tetapi kita perlu menyemak nilai bendera ini pada objek dan menyelesaikan kerja kita sendiri dengan betul! Itulah sebabnya Threadkelas mempunyai boolean isInterrupted()kaedah. Mari kita kembali kepada contoh jam yang terdapat dalam pelajaran dalam kursus asas. Untuk kemudahan, kami telah memudahkannya sedikit:

public class Clock extends Thread {

   public static void main(String[] args) throws InterruptedException {
       Clock clock = new Clock();
       clock.start();

       Thread.sleep(10000);
       clock.interrupt();
   }

   public void run() {
       Thread current = Thread.currentThread();

       while (!current.isInterrupted())
       {
           try {
               Thread.sleep(1000);
           } catch (InterruptedException e) {
               System.out.println("The thread was interrupted");
               break;
           }
           System.out.println("Tick");
       }
   }
}

Dalam kes ini, jam dimulakan dan mula berdetik setiap saat. Pada saat ke-10, kami mengganggu urutan jam. Seperti yang anda sedia maklum, jika urutan yang kami cuba ganggu berada dalam salah satu keadaan menunggu, hasilnya ialah InterruptedException. Ini adalah pengecualian yang diperiksa, jadi kami boleh menangkapnya dengan mudah dan melaksanakan logik kami untuk menyelesaikan program. Dan itulah yang kami lakukan. Inilah keputusan kami: Tick Tick Tick Tcik Tick Tick Tick Tick Tick Thread telah terganggu Ini mengakhiri pengenalan kami kepada Threadkaedah yang paling penting dalam kelas. Semoga berjaya!