Kaedah Wait() dalam Java

Dalam artikel ini, kita akan melihat kaedah wait() untuk mengawal benang, dan kaedah notify() / notifyAll() . Kaedah ini ditakrifkan dalam kelas asas java.lang.Object dan, sewajarnya, mekanisme pewarisan yang ada dalam Java menyediakan kaedah ini kepada semua kelas secara mutlak. Iaitu, apabila anda mencipta kelas anda sendiri dan objeknya, anda sentiasa boleh memanggil kaedah ini.

Bagaimanakah kaedah wait() dan notify()/notifyAll() berfungsi?

• tunggu () . secara ringkasnya, kaedah ini melepaskan monitor dan meletakkan utas panggilan ke dalam keadaan menunggu sehingga utas lain memanggil kaedah notify() / notifyAll() ;
• maklumkan() . Meneruskan kerja benang yang kaedah wait()nya sebelum ini dipanggil;
• kaedah notifyAll() menyambung semula semua utas yang sebelum ini mempunyai kaedah wait() dipanggil.

Sekarang mari kita lihat dengan lebih dekat kaedah wait() . Kelas Objek mengandungi tiga pilihan untuk kaedah ini:

• public final native void wait(long timeoutMillis) throws InterruptedException ; Ia menyebabkan benang semasa menunggu sehingga ia terjaga. Biasanya ia berlaku dengan diberitahu atau diganggu, atau sehingga jumlah masa nyata tertentu telah berlalu.

• public final void wait() throws InterruptedException . Bukan kebetulan bahawa kami menulis kaedah tanpa parameter sebagai yang kedua. Malah, jika anda melihat kodnya, ia merujuk kepada varian pertama kaedah, ia hanya mempunyai hujah 0L.

• tunggu akhir awam (masa tamat lama, int nanos) . Menyebabkan urutan semasa menunggu sehingga ia dibangkitkan, biasanya dengan dimaklumkan atau terganggu, atau sehingga jumlah masa nyata tertentu telah berlalu.

Kaedah wait () bertujuan untuk menggantung benang panggilan. Apakah maksudnya? Kaedah ini tergolong dalam kelas. Berdasarkan kelas, anda mencipta objek. Objek wujud dalam beberapa utas. Iaitu, objek dicipta dalam beberapa utas. Dalam utas di mana objek ini berfungsi, jika anda memanggil wait() di dalamnya, ini akan membawa kepada fakta bahawa utas ini akan berhenti. Objek itu sendiri bertindak sebagai sejenis monitor. Apa itu? Sudah jelas bahawa anda boleh mencipta objek yang berbeza dan kesemuanya akan mengandungi wait()kaedah. Terdapat pemahaman tentang objek yang menyebabkan terhentinya benang tertentu. Benang berhenti dan akan menunggu selagi ia ditulis dalam parameter. Dan kemudian ia akan bermula. Benang ini tidak boleh bermula sendiri. Untuk menyambung kerja, terdapat kaedah notify dan notifyAll. Panggilan untuk notify() atau notifyAll() mesti memainkan beberapa thread lain. Dengan wait() , anda boleh menghentikan berbilang thread dan mulakan semua thread dengan notifyAll() . Jika berbilang utas dihentikan dan notify() dipanggil, adalah mustahil untuk mengetahui dengan tepat utas mana yang akan menyambung semula kaedah ini. Jika tiada utas menunggu pada kaedah wait() , maka tiada apa yang berlaku apabila notify() ornotifyAll() dipanggil. Benang boleh memanggil kaedah wait() atau notify() pada objek tertentu hanya jika ia mempunyai kunci pada objek itu pada masa ini. wait() , notify() , dan notifyAll() hanya perlu dipanggil daripada kod yang disegerakkan.

Contoh kaedah Wait().

Di sini kami mempunyai salah satu contoh paling popular yang menggambarkan cara kaedah itu berfungsi. Katakan kita mempunyai kedai, pengeluar dan pengguna. Pengilang memindahkan beberapa produk pengeluaran ke kedai, selepas itu pengguna boleh membawanya. Biarlah pengilang perlu mengeluarkan 8 barang masing-masing, pengguna mesti membeli semuanya. Tetapi pada masa yang sama, tidak lebih daripada 6 item boleh berada di gudang pada masa yang sama. Untuk menyelesaikan masalah ini, kami menggunakan kaedah wait() dan notify() . Mari kita tentukan tiga kelas: Pasaran , Pengeluar dan Pelanggan . Kaedah Manufacturer in the run() menambah 8 produk pada objek Market menggunakannyakaedah put() . Klien dalam kaedah run() dalam gelung memanggil kaedah dapatkan objek Pasaran untuk mendapatkan produk ini. Kaedah letak dan dapatkan kelas Pasaran disegerakkan. Untuk menjejaki kehadiran barangan dalam kelas Pasaran , kami menyemak nilai pembolehubah item. Kaedah get() untuk mendapatkan produk hanya boleh digunakan jika terdapat sekurang-kurangnya satu produk. Oleh itu, dalam kaedah dapatkan, kami menyemak sama ada produk itu hilang. Jika item tidak tersedia, kaedah wait() dipanggil. Kaedah ini melepaskan monitor objek Market dan menyekat kaedah get sehingga notify()kaedah dipanggil pada monitor yang sama. Apabila item ditambah dalam kaedah put() dan notify() dipanggil, kaedah get() mendapat monitor. Selepas itu, pelanggan kami menerima item. Untuk melakukan ini, mesej dipaparkan, dan nilai item dikurangkan. Akhir sekali, panggilan kaedah notify() menandakan kaedah put() untuk diteruskan. Dalam kaedah put() , logik yang serupa berfungsi, hanya sekarang kaedah put() harus berfungsi jika tidak ada lebih daripada 6 produk dalam 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, menggunakan wait() dalam kaedah get() , kami sedang menunggu Pengilang menambah item baharu. Dan selepas menambah, kami memanggil notify() , seolah-olah mengatakan bahawa satu tempat telah menjadi percuma di Warehouse , dan anda boleh menambah lagi. Dalam kaedah put() , menggunakan wait() , kami sedang menunggu pelepasan ruang pada Warehouse . Selepas ruang kosong, kami menambah item, notify() memulakan utas dan Klien boleh mengambil item tersebut. Berikut adalah output program kami: