Tunggu () Metode di Jawa

Pada artikel ini, kita akan melihat metode wait() untuk mengontrol thread, dan metode notify() / notifyAll() . Metode ini didefinisikan dalam kelas dasar java.lang.Object dan, karenanya, mekanisme pewarisan yang ada di Java menyediakan metode ini untuk semua kelas. Yaitu, saat Anda membuat kelas Anda sendiri dan objeknya, Anda selalu dapat memanggil metode ini.

Bagaimana cara kerja metode wait() dan notify()/notifyAll()?

• tunggu() . singkatnya, metode ini melepaskan monitor dan menempatkan utas pemanggil ke status tunggu hingga utas lain memanggil metode notify() / notifyAll() ;
• beri tahu() . Melanjutkan pekerjaan utas yang metode wait() sebelumnya dipanggil;
• metode notifyAll() melanjutkan semua utas yang sebelumnya telah memanggil metode wait() mereka .

Sekarang mari kita lihat lebih dekat metode wait() . Kelas Object berisi tiga opsi untuk metode ini:

• public final native void wait(long timeoutMillis) throws InterruptedException ; Ini menyebabkan utas saat ini menunggu hingga terbangun. Biasanya ini terjadi dengan diberitahukan atau diinterupsi, atau hingga sejumlah waktu nyata telah berlalu.

• public final void wait() melempar InterruptedException . Bukan kebetulan bahwa kami menulis metode tanpa parameter sebagai yang kedua. Faktanya, jika Anda melihat kodenya, ini mengacu pada varian pertama dari metode tersebut, hanya memiliki argumen 0L.

• penantian akhir publik (batas waktu lama, int nanos) . Menyebabkan utas saat ini menunggu hingga terbangun, biasanya dengan diberi tahu atau terputus, atau hingga sejumlah waktu nyata telah berlalu.

Metode wait() dimaksudkan untuk menangguhkan utas panggilan. Apa artinya? Metode ini milik kelas. Berdasarkan kelas, Anda membuat objek. Objek ada di beberapa utas. Artinya, objek dibuat di beberapa utas. Di utas tempat objek ini berfungsi, jika Anda memanggil wait() di dalamnya, ini akan mengarah pada fakta bahwa utas ini akan berhenti. Objek itu sendiri bertindak sebagai semacam monitor. Apa itu? Jelas bahwa Anda dapat membuat objek yang berbeda dan semuanya akan berisi wait()metode. Ada pemahaman tentang objek mana yang menyebabkan penghentian utas tertentu. Utas berhenti dan akan menunggu selama itu tertulis di parameter. Dan kemudian akan dimulai. Utas ini tidak dapat dimulai sendiri. Untuk melanjutkan pekerjaan, ada metode beri tahu dan beri tahu Semua. Panggilan untuk notify() atau notifyAll() harus memainkan beberapa utas lainnya. Dengan wait() , Anda dapat menghentikan banyak utas, dan memulai semua utas dengan notifyAll() . Jika beberapa utas dihentikan dan beri tahu () dipanggil, tidak mungkin untuk mengetahui dengan tepat utas mana yang akan melanjutkan metode ini. Jika tidak ada utas menunggu pada metode wait() , maka tidak ada yang terjadi saat notify() ataunotifyAll() dipanggil. Sebuah thread dapat memanggil metode wait() atau notify() pada objek tertentu hanya jika saat ini memiliki kunci pada objek tersebut. wait() , notify() , dan notifyAll() hanya boleh dipanggil dari kode yang disinkronkan.

Contoh metode Wait()

Di sini kami memiliki salah satu contoh paling populer yang mengilustrasikan cara kerja metode ini. Katakanlah kita memiliki toko, produsen, dan konsumen. Pabrikan mentransfer beberapa produk produksi ke toko, setelah itu konsumen dapat mengambilnya. Misalkan pabrikan harus memproduksi 8 barang, masing-masing, konsumen harus membeli semuanya. Tetapi pada saat yang sama, tidak lebih dari 6 item dapat berada di gudang pada saat yang bersamaan. Untuk mengatasi masalah ini, kami menggunakan metode wait() dan notify() . Mari kita tentukan tiga kelas: Market , Manufacturer dan Client . Produsen dalam metode run() menambahkan 8 produk ke objek Market menggunakanmetode put() . Klien dalam metode run() dalam satu lingkaran memanggil metode get dari objek Market untuk mendapatkan produk ini. Metode put dan get dari kelas Market disinkronkan. Untuk melacak keberadaan barang di kelas Pasar , kami memeriksa nilai variabel barang. Metode get() untuk mendapatkan produk hanya boleh diaktifkan jika setidaknya ada satu produk. Oleh karena itu, dalam metode get, kami memeriksa apakah produk tersebut hilang. Jika item tidak tersedia, metode wait() dipanggil. Metode ini melepaskan monitor objek Market dan memblokir metode get sampai notify()metode dipanggil pada monitor yang sama. Ketika sebuah item ditambahkan dalam metode put() dan notify() dipanggil, metode get() mendapatkan monitor. Setelah itu, klien kami menerima item. Untuk melakukan ini, pesan ditampilkan, dan nilai item dikurangi. Terakhir, pemanggilan metode notify() menandakan metode put() untuk melanjutkan. Dalam metode put() , logika serupa berfungsi, hanya sekarang metode put() harus berfungsi jika tidak ada lebih dari 6 produk di Market .

class Market {

   private int item = 0;

   public synchronized void get() {
       //here we use wait() method
       while (item < 1) {
           try {
               wait();
           }
           catch (InterruptedException e) {
           }
       }
       item--;
       System.out.println("A client has bought 1 item...");
       System.out.println("Items quantity in Market warehouse... " + item);
       notify();
   }

   public synchronized void put() {
       //here we use wait() method when the Warehouse is full
       while (item >= 6) {
           try {
               wait();
           }
           catch (InterruptedException e) {
           }
       }
       item ++;
       System.out.println("Manufacturer has added 1 more item...");
       System.out.println("Now there are " + item + " items in Warehouse" );
       notify();
   }
}

class Manufacturer implements Runnable {

   Market market;

   Manufacturer(Market market) {
       this.market = market;
   }


   public void run() {
       for (int i = 0; i < 8; i++) {
           market.put();
       }
   }
}

class Client implements Runnable {

   Market market;
   Client(Market market) {
       this.market = market;
   }
   public void run() {
       for (int i = 0; i < 8; i++) {
           market.get();
       }
   }
}
//wait() method test class
public class WaitTest {
   public static void main(String[] args) {

       Market market = new Market();
       Manufacturer manufacturer = new Manufacturer(market);
       Client client = new Client(market);
       new Thread(manufacturer).start();
       new Thread(client).start();
   }
}

Di sini, dengan menggunakan wait() dalam metode get() , kita menunggu Produsen untuk menambahkan item baru. Dan setelah menambahkan, kami memanggil notify() , seolah mengatakan bahwa satu tempat telah menjadi gratis di Warehouse , dan Anda dapat menambahkan lebih banyak. Dalam metode put() , menggunakan wait() , kami menunggu pelepasan ruang di Warehouse . Setelah ruang kosong, kami menambahkan item, beri tahu () memulai utas dan Klien dapat mengambil item tersebut. Berikut adalah output dari program kami: