Método ArrayBlockingQueue offer() en Java

ArrayBlockingQueue es una cola de bloqueo limitada que almacena los elementos respaldados internamente por una array.

• La clase ArrayBlockingQueue es miembro de Java Collections Framework.
• Acotado significa que tendrá un tamaño fijo, no puede almacenar el número de elementos más que la capacidad de la cola.
• La cola también sigue la regla FIFO (primero en entrar, primero en salir) para almacenar y eliminar elementos de la cola.
• Si intenta colocar un elemento en una cola llena o tomar un elemento de una cola vacía, la cola lo bloqueará.

Hay dos tipos de método de oferta() según el parámetro que se le pase:

1. El método de oferta ( elemento E ) inserta el elemento pasado como parámetro al método al final de esta cola (ArrayBlockingQueue), si la cola no está llena. Devuelve verdadero cuando la operación de suma es exitosa y falso si esta cola está llena. Este método es preferible al método add() porque el método add arroja un error cuando la cola está llena, pero el método offer() devuelve falso en tal situación.
   Sintaxis:

   public boolean offer(E e)

   Parámetro: El método toma un parámetro, elemento . Esto se refiere al elemento que se agregará en la cola.

   Valor de retorno: este método devuelve True cuando la operación de suma es exitosa y false si esta cola está llena.

   Excepción El método lanza NullPointerException si el elemento especificado es nulo.

   Los siguientes programas ilustran el método de oferta (elemento E) de ArrayBlockingQueue:
   Programa 1:

   // Demonstrating offer(E element) method of ArrayBlockingQueue    import java.util.concurrent.ArrayBlockingQueue;    public class GFG {    public static void main(String[] args) {     // Define capacity of ArrayBlockingQueue     int capacity = 5;            // Create object of ArrayBlockingQueue     ArrayBlockingQueue<Integer> queue =            new ArrayBlockingQueue<Integer>(capacity);            // Add 5 elements to ArrayBlockingQueue     System.out.println("adding 423: "+queue.offer(423));     System.out.println("adding 243: "+queue.offer(243));     System.out.println("adding 237: "+queue.offer(237));     System.out.println("adding 867: "+queue.offer(867));     System.out.println("adding 23: "+queue.offer(23));            // Check whether queue is full or not     if(queue.remainingCapacity()==0) {         System.out.println("queue is full");         System.out.println("queue contains "+queue);     }else {         System.out.println("queue is not full");         System.out.println("queue contains "+queue);     }            // Try to add more elements     System.out.println("adding 123: "+queue.offer(123));     System.out.println("adding 321: "+queue.offer(321));        }  }

   Producción:

   adding 423: true
   adding 243: true
   adding 237: true
   adding 867: true
   adding 23: true
   queue is full
   queue contains [423, 243, 237, 867, 23]
   adding 123: false
   adding 321: false
   

   Programa 2:

   // Program Demonstrate offer(E e) method of ArrayBlockingQueue    import java.util.concurrent.ArrayBlockingQueue;    public class GFG {        // create a User Object with name and age as an attribute     public class User {            public String name;         public String age;         User(String name, String age)         {             this.name = name;             this.age = age;         }     }        // Main Method     public static void main(String[] args)     {         GFG gfg = new GFG();         gfg.offerExample();     }        // Method to give example of contains function     public void offerExample()     {            // Define the capacity of ArrayBlockingQueue         int capacity = 5;            // Create object of ArrayBlockingQueue         ArrayBlockingQueue<User> queue =                  new ArrayBlockingQueue<User>(capacity);            // Create user objects         User user1 = new User("Aman", "24");         User user2 = new User("Amar", "23");         User user3 = new User("Sanjeet", "25");         User user4 = new User("Suvo", "26");         User user5 = new User("Ravi", "22");            // Add Objects to ArrayBlockingQueue         System.out.println("adding user having name = "                 + user1.name + ": " + queue.offer(user1));         System.out.println("adding user having name = "                 + user2.name + ": " + queue.offer(user2));         System.out.println("adding user having name = "                 + user3.name + ": " + queue.offer(user3));         System.out.println("adding user having name = "                 + user4.name + ": " + queue.offer(user4));         System.out.println("adding user having name = "                 + user5.name + ": " + queue.offer(user5));            // Check whether the queue is full or not         if (queue.remainingCapacity() == 0) {             System.out.println("queue is full");         }         else {             System.out.println("queue is not full");         }            // Create more user objects         User user6 = new User("Ram", "20");         User user7 = new User("Mohan", "27");            // Add users in queue         System.out.println("adding user having name = "                 + user6.name + ": " + queue.offer(user6));         System.out.println("adding user having name = "                 + user7.name + ": " + queue.offer(user7));     } }

   Producción:

   adding user having name = Aman: true
   adding user having name = Amar: true
   adding user having name = Sanjeet: true
   adding user having name = Suvo: true
   adding user having name = Ravi: true
   queue is full
   adding user having name = Ram: false
   adding user having name = Mohan: false
   

2. El método de oferta ( elemento E, tiempo de espera prolongado, unidad de unidad de tiempo ) inserta el elemento pasado como parámetro al método al final de esta cola (ArrayBlockingQueue) si la cola no está llena. Esperará hasta un tiempo específico para que haya espacio disponible si la cola está llena . Devuelve verdadero cuando la operación de adición es exitosa y falso si esta cola está llena y transcurre el tiempo de espera especificado antes de que haya espacio disponible. Este método es útil cuando queremos esperar a que la cola elimine su elemento y cuando la cola no está llena, el elemento se agregará a la cola, pero podemos esperar un tiempo específico y este tiempo lo podemos definir nosotros.

   Sintaxis:

   public boolean offer(E e, long timeout, TimeUnit unit) throws InterruptedException

   Parámetro: El método toma tres parámetros:

   • elemento (Objeto)- el elemento para agregar en la cola.
   • tiempo de espera (largo): cuánto tiempo esperar antes de darse por vencido, en unidades de la unidad.
   • unidad (TimeUnit): una unidad de tiempo que determina cómo interpretar el parámetro de tiempo de espera.

   Valor devuelto: el método devuelve True cuando la adición del método es exitosa y false si transcurre el tiempo de espera especificado antes de que haya espacio disponible.

   Excepción: el método arroja dos tipos de excepciones:

   • InterruptedException : si se interrumpe durante la espera.
   • NullPointerException : si el elemento especificado es nulo.

   Los siguientes programas ilustran el método de oferta (elemento E, tiempo de espera prolongado, unidad de unidad de tiempo) de ArrayBlockingQueue:

   // Program Demonstrate offer(E e, long timeout, TimeUnit unit) // method of ArrayBlockingQueue    import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.TimeUnit;    public class GFG {        public static void main(String[] args)                    throws InterruptedException     {         // Define capacity of ArrayBlockingQueue         int capacity = 5;            // Create object of ArrayBlockingQueue         ArrayBlockingQueue<Integer> queue =              new ArrayBlockingQueue<Integer>(capacity);            // Add 5 elements to ArrayBlockingQueue having         // Timeout in seconds with value 10 secs         System.out.println("adding 423: " +                queue.offer(433, 10, TimeUnit.SECONDS));         System.out.println("adding 456: " +                queue.offer(456, 10, TimeUnit.SECONDS));         System.out.println("adding 987: " +                queue.offer(987, 10, TimeUnit.SECONDS));         System.out.println("adding 578: " +                queue.offer(578, 10, TimeUnit.SECONDS));         System.out.println("adding 852: " +                queue.offer(852, 10, TimeUnit.SECONDS));            // Check whether queue is full or not         if (queue.remainingCapacity() == 0) {             System.out.println("queue is full");             System.out.println("queue contains " + queue);         }         else {             System.out.println("queue is not full");             System.out.println("queue contains " + queue);         }            // Try to add more elements         System.out.println("adding 546: " +                    queue.offer(546, 10, TimeUnit.SECONDS));     } }

   Producción:

   adding 423: true
   adding 456: true
   adding 987: true
   adding 578: true
   adding 852: true
   queue is full
   queue contains [433, 456, 987, 578, 852]
   adding 546: false
   

Referencia: https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/ArrayBlockingQueue.html#offer(E)