Java ArrayBlockingQueue

Dalam tutorial ini, kita akan belajar tentang kelas ArrayBlockingQueue dan metodenya dengan bantuan contoh.

ArrayBlockingQueue class framework Java Collections menyediakan implementasi antrian pemblokiran menggunakan array.

Ini mengimplementasikan antarmuka Java BlockingQueue.

Membuat ArrayBlockingQueue

Untuk membuat antrian pemblokiran larik, kita harus mengimpor kode java.util.concurrent.ArrayBlockingQueue paket.

Setelah kita mengimpor paket, berikut adalah cara membuat antrian pemblokiran array di Java:

ArrayBlockingQueue<Type> animal = new ArrayBlockingQueue<>(int capacity);

Di sini,

Jenis - jenis antrian pemblokiran larik
kapasitas - ukuran antrian pemblokiran larik

Misalnya,

// Creating String type ArrayBlockingQueue with size 5
ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>(5);

// Creating Integer type ArrayBlockingQueue with size 5
ArrayBlockingQueue<Integer> age = new ArrayBlockingQueue<>(5);

Catatan: Adalah wajib untuk memberikan ukuran array.

Metode ArrayBlockingQueue

ArrayBlockingQueue class menyediakan implementasi semua metode dalam BlockingQueue antarmuka.

Metode ini digunakan untuk menyisipkan, mengakses, dan menghapus elemen dari antrian pemblokiran array.

Juga, kita akan belajar tentang dua metode put() dan take() yang mendukung operasi pemblokiran dalam antrian pemblokiran larik.

Kedua metode ini membedakan antrian pemblokiran larik dari antrian tipikal lainnya.

Sisipkan Elemen

add() - Menyisipkan elemen tertentu ke antrian pemblokiran larik. Itu melempar pengecualian jika antrian penuh.
offer() - Menyisipkan elemen tertentu ke antrian pemblokiran larik. Ini mengembalikan false jika antrian sudah penuh.

Misalnya,

import java.util.concurrent.ArrayBlockingQueue;

class Main {
    public static void main(String[] args) {
        ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>(5);

        // Using add()
        animals.add("Dog");
        animals.add("Cat");

        // Using offer()
        animals.offer("Horse");
        System.out.println("ArrayBlockingQueue: " + animals);
    }
}

Keluaran

ArrayBlockingQueue: [Dog, Cat, Horse]

Elemen Akses

peek() - Mengembalikan elemen dari depan antrian pemblokiran larik. Ia mengembalikan null jika antrian kosong.
iterator() - Mengembalikan objek iterator untuk mengakses elemen secara berurutan dari antrian pemblokiran array. Itu melempar pengecualian jika antrian kosong. Kita harus mengimpor java.util.Iterator paket untuk menggunakannya.

Misalnya,

import java.util.concurrent.ArrayBlockingQueue;
import java.util.Iterator;

class Main {
    public static void main(String[] args) {
        ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>(5);

        // Add elements
        animals.add("Dog");
        animals.add("Cat");
        animals.add("Horse");
        System.out.println("ArrayBlockingQueue: " + animals);

        // Using peek()
        String element = animals.peek();
        System.out.println("Accessed Element: " + element);

        // Using iterator()
        Iterator<String> iterate = animals.iterator();
        System.out.print("ArrayBlockingQueue Elements: ");

        while(iterate.hasNext()) {
            System.out.print(iterate.next());
            System.out.print(", ");
        }
    }
}

Keluaran

ArrayBlockingQueue: [Dog, Cat, Horse]
Accessed Element: Dog
ArrayBlockingQueue Elements: Dog, Cat, Horse,

Hapus Elemen

remove() - Mengembalikan dan menghapus elemen tertentu dari antrian pemblokiran array. Itu melempar pengecualian jika antrian kosong.
poll() - Mengembalikan dan menghapus elemen tertentu dari antrian pemblokiran array. Ini mengembalikan null jika antrian kosong.
clear() - Menghapus semua elemen dari antrian pemblokiran larik.

Misalnya,

import java.util.concurrent.ArrayBlockingQueue;

class Main {
    public static void main(String[] args) {
        ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>(5);

        animals.add("Dog");
        animals.add("Cat");
        animals.add("Horse");
        System.out.println("ArrayBlockingQueue: " + animals);

        // Using remove()
        String element1 = animals.remove();
        System.out.println("Removed Element:");
        System.out.println("Using remove(): " + element1);

        // Using poll()
        String element2 = animals.poll();
        System.out.println("Using poll(): " + element2);

        // Using clear()
        animals.clear();
        System.out.println("Updated ArrayBlockingQueue: " + animals);
    }
}

Keluaran

ArrayBlockingQueue: [Dog, Cat, Horse]
Removed Elements:
Using remove(): Dog
Using poll(): Cat
Updated ArrayBlockingQueue: []

put() dan take() Metode

Dalam proses multithreading, kita dapat menggunakan put() dan take() untuk memblokir pengoperasian satu utas untuk menyinkronkannya dengan utas lainnya. Metode ini akan menunggu hingga berhasil dieksekusi.

metode put()

Untuk menambahkan elemen ke akhir antrian pemblokiran array, kita dapat menggunakan put() metode.

Jika antrian pemblokiran larik penuh, ia akan menunggu sampai ada ruang dalam antrian pemblokiran larik untuk menambahkan elemen.

Misalnya,

import java.util.concurrent.ArrayBlockingQueue;

class Main {
    public static void main(String[] args) {
        ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>(5);

       try {
        // Add elements to animals
           animals.put("Dog");
           animals.put("Cat");
           System.out.println("ArrayBlockingQueue: " + animals);
        }
        catch(Exception e) {
            System.out.println(e);
        }
    }
}

Keluaran

ArrayBlockingQueue: [Dog, Cat]

Di sini, put() metode mungkin melempar InterruptedException jika terganggu saat menunggu. Oleh karena itu, kita harus menyertakannya di dalam try..catch blokir.

ambil() Metode

Untuk mengembalikan dan menghapus elemen dari depan antrian pemblokiran array, kita dapat menggunakan take() metode.

Jika antrian pemblokiran larik kosong, ia menunggu sampai ada elemen dalam antrian pemblokiran larik yang akan dihapus.

Misalnya,

import java.util.concurrent.ArrayBlockingQueue;

class Main {
    public static void main(String[] args) {
        ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>(5);

       try {
           //Add elements to animals
           animals.put("Dog");
           animals.put("Cat");
           System.out.println("ArrayBlockingQueue: " + animals);

           // Remove an element
           String element = animals.take();
           System.out.println("Removed Element: " + element);
        }
        catch(Exception e) {
            System.out.println(e);
        }
    }
}

Keluaran

ArrayBlockingQueue: [Dog, Cat]
Removed Element: Dog

Di sini, take() metode akan melempar InterrupedException jika terganggu saat menunggu. Oleh karena itu, kita harus menyertakannya di dalam try...catch blokir.

Metode Lain

Metode	Deskripsi
`contains(element)`	Menelusuri antrean pemblokiran larik untuk elemen yang ditentukan.Jika elemen ditemukan, ia mengembalikan `true` , jika tidak mengembalikan `false` .
`size()`	Mengembalikan panjang antrian pemblokiran larik.
`toArray()`	Mengonversi antrian pemblokiran larik menjadi larik dan mengembalikannya.
`toString()`	Mengonversi antrian pemblokiran array menjadi string

Mengapa menggunakan ArrayBlockingQueue?

ArrayBlockingQueue menggunakan array sebagai penyimpanan internalnya.

Ini dianggap sebagai aman untuk thread koleksi. Oleh karena itu, umumnya digunakan dalam aplikasi multi-threading.

Misalkan, satu utas memasukkan elemen ke antrean dan utas lainnya menghapus elemen dari antrean.

Sekarang, jika utas pertama lebih lambat dari utas kedua, maka antrian pemblokiran array dapat membuat utas kedua menunggu hingga utas pertama menyelesaikan operasinya.

Antrian Pemblokiran Java Java LinkedBlockingQueue

java