Breaking

Post Top Ad

Your Ad Spot

sábado, 21 de diciembre de 2019

Java LinkedBlockingQueue

En este tutorial, aprenderemos sobre la clase LinkedBLockingQueue y sus métodos con la ayuda de ejemplos.
anuncios a través de carbonoAdobe Creative Cloud para equipos a partir de $ 33.99 por mes.ANUNCIOS A TRAVÉS DE CARBONO
La LinkedBlockingQueueclase del Collectionsmarco de Java proporciona la implementación de la cola de bloqueo mediante una lista vinculada.
Implementa la interfaz Java BlockingQueue .
ArrayBlockingQueue implementa la interfaz BlockingQueue en Java.

Crear LinkedBlockingQueue

Para crear una cola de bloqueo vinculada, debemos importar el java.util.concurrent.LinkedBlockingQueuepaquete.
Así es como podemos crear una cola de bloqueo vinculada en Java:
1. Sin la capacidad inicial
  1. LinkedBlockingQueue<Type> animal = new LinkedBlockingQueue<>();
Aquí la capacidad inicial predeterminada será 2 31 -1.
2. Con la capacidad inicial
  1. LinkedBlockingQueue<Type> animal = new LinkedBlockingQueue<>(int capacity);
Aquí,
  • Tipo : el tipo de la cola de bloqueo vinculada
  • capacidad : el tamaño de la cola de bloqueo vinculada
Por ejemplo,
  1. // Creating String type LinkedBlockingQueue with size 5
  2. LinkedBlockingQueue<String> animals = new LinkedBlockingQueue<>(5);
  3. // Creating Integer type LinkedBlockingQueue with size 5
  4. LinkedBlockingQueue<Integer> age = new LinkedBlockingQueue<>(5);
Nota: No es obligatorio proporcionar el tamaño de la lista vinculada.

Métodos de LinkedBlockingQueue

La LinkedBlockingQueueclase proporciona la implementación de todos los métodos en la interfaz BlockingQueue .
Estos métodos se utilizan para insertar, acceder y eliminar elementos de colas de bloqueo vinculadas.
Además, aprenderemos sobre dos métodos put()take()que admiten la operación de bloqueo en la cola de bloqueo vinculada.
Estos dos métodos distinguen la cola de bloqueo vinculada de otras colas típicas.

Insertar elementos

  • add()- Inserta un elemento especificado en la cola de bloqueo vinculada. Lanza una excepción si la cola está llena.
  • offer()- Inserta un elemento especificado en la cola de bloqueo vinculada. Regresa falsesi la cola está llena.
Por ejemplo,
  1. import java.util.concurrent.LinkedBlockingQueue;
  2. class Main {
  3. public static void main(String[] args) {
  4. LinkedBlockingQueue<String> animals = new LinkedBlockingQueue<>(5);
  5. // Using add()
  6. animals.add("Dog");
  7. animals.add("Cat");
  8. // Using offer()
  9. animals.offer("Horse");
  10. System.out.println("LinkedBlockingQueue: " + animals);
  11. }
  12. }
Salida
LinkedBlockingQueue: [Perro, Gato, Caballo]

Elementos de acceso

  • peek()- Devuelve un elemento desde el frente de la cola de bloqueo vinculada. Regresa nullsi la cola está vacía.
  • iterator()- Devuelve un objeto iterador para acceder secuencialmente a un elemento desde la cola de bloqueo vinculada. Lanza una excepción si la cola está vacía. Debemos importar el java.util.Iteratorpaquete para usarlo.
Por ejemplo,
  1. import java.util.concurrent.LinkedBlockingQueue;
  2. import java.util.Iterator;
  3. class Main {
  4. public static void main(String[] args) {
  5. LinkedBlockingQueue<String> animals = new LinkedBlockingQueue<>(5);
  6. // Add elements
  7. animals.add("Dog");
  8. animals.add("Cat");
  9. animals.add("Horse");
  10. System.out.println("LinkedBlockingQueue: " + animals);
  11. // Using peek()
  12. String element = animals.peek();
  13. System.out.println("Accessed Element: " + element);
  14. // Using iterator()
  15. Iterator<String> iterate = animals.iterator();
  16. System.out.print("LinkedBlockingQueue Elements: ");
  17. while(iterate.hasNext()) {
  18. System.out.print(iterate.next());
  19. System.out.print(", ");
  20. }
  21. }
  22. }
Salida
LinkedBlockingQueue: [Perro, Gato, Caballo]
Elemento al que se accede: perro
Elementos LinkedBlockingQueue: perro, gato, caballo,

Eliminar elementos

  • remove()- Devuelve y elimina un elemento especificado de la cola de bloqueo vinculada. Lanza una excepción si la cola está vacía.
  • poll()- Devuelve y elimina un elemento especificado de la cola de bloqueo vinculada. Regresa nullsi la cola está vacía.
  • clear() - Elimina todos los elementos de la cola de bloqueo vinculada.
Por ejemplo,
  1. import java.util.concurrent.LinkedBlockingQueue;
  2. class Main {
  3. public static void main(String[] args) {
  4. LinkedBlockingQueue<String> animals = new LinkedBlockingQueue<>(5);
  5. animals.add("Dog");
  6. animals.add("Cat");
  7. animals.add("Horse");
  8. System.out.println("LinkedBlockingQueue " + animals);
  9. // Using remove()
  10. String element1 = animals.remove();
  11. System.out.println("Removed Element:");
  12. System.out.println("Using remove(): " + element1);
  13. // Using poll()
  14. String element2 = animals.poll();
  15. System.out.println("Using poll(): " + element2);
  16. // Using clear()
  17. animals.clear();
  18. System.out.println("Updated LinkedBlockingQueue " + animals);
  19. }
  20. }
Salida
LinkedBlockingQueue: [Perro, Gato, Caballo]
Elementos eliminados:
Usando remove (): Perro
Usando poll (): Cat
LinkedBlockingQueue actualizado: []

Métodos put () y take ()

En procesos de subprocesos múltiples, podemos usar put()take()bloquear la operación de un hilo para sincronizarlo con otro hilo. Estos métodos esperarán hasta que puedan ejecutarse con éxito.

Método put ()

Para insertar el elemento especificado al final de una cola de bloqueo vinculada, utilizamos el put()método
Si la cola de bloqueo vinculada está llena, espera hasta que haya espacio en la cola de bloqueo vinculada para insertar el elemento.
Por ejemplo,
  1. import java.util.concurrent.LinkedBlockingQueue;
  2. class Main {
  3. public static void main(String[] args) {
  4. LinkedBlockingQueue<String> animals = new LinkedBlockingQueue<>(5);
  5. try {
  6. // Add elements to animals
  7. animals.put("Dog");
  8. animals.put("Cat");
  9. System.out.println("LinkedBlockingQueue: " + animals);
  10. }
  11. catch(Exception e) {
  12. System.out.println(e);
  13. }
  14. }
  15. }
Salida
LinkedBlockingQueue: [Perro, Gato]
Aquí, el put()método puede arrojar un mensaje InterruptedExceptionsi se interrumpe mientras espera. Por lo tanto, debemos encerrarlo dentro de un bloque try..catch .

Método take ()

Para devolver y eliminar un elemento del frente de la cola de bloqueo vinculada, podemos usar el take()método
Si la cola de bloqueo vinculada está vacía, espera hasta que haya elementos en la cola de bloqueo vinculada que se eliminarán.
Por ejemplo,
  1. import java.util.concurrent.LinkedBlockingQueue;
  2. class Main {
  3. public static void main(String[] args) {
  4. LinkedBlockingQueue<String> animals = new LinkedBlockingQueue<>(5);
  5. try {
  6. //Add elements to animals
  7. animals.put("Dog");
  8. animals.put("Cat");
  9. System.out.println("LinkedBlockingQueue: " + animals);
  10. // Remove an element
  11. String element = animals.take();
  12. System.out.println("Removed Element: " + element);
  13. System.out.println("New LinkedBlockingQueue: " + animals);
  14. }
  15. catch(Exception e) {
  16. System.out.println(e);
  17. }
  18. }
  19. }
Salida
LinkedBlockingQueue: [Perro, Gato]
Elemento eliminado: perro
Nuevo LinkedBlockingQueue: [Cat]
Aquí, el take()método arrojará un InterrupedExceptionsi se interrumpe mientras espera. Por lo tanto, debemos encerrarlo dentro de un try...catchbloque.

Otros metodos

MétodosDescripciones
contains(element)Busca en la cola de bloqueo vinculada el elemento especificado. Si se encuentra el elemento, regresa true, si no regresa false.
size()Devuelve la longitud de la cola de bloqueo vinculada.
toArray()Convierte la cola de bloqueo vinculada en una matriz y devuelve la matriz.
toString()Convierte la cola de bloqueo vinculada en una cadena.

¿Por qué usar LinkedBlockingQueue?

Los LinkedBlockingQueueusos vinculados listas como su almacenamiento interno.
Se considera una colección segura para subprocesos . Por lo tanto, generalmente se usa en aplicaciones de subprocesos múltiples.
Supongamos que un hilo está insertando elementos en la cola y otro hilo está eliminando elementos de la cola.
Ahora, si el primer subproceso es más lento que el segundo subproceso, la cola de bloqueo vinculada puede hacer que el segundo subproceso espere hasta que el primer subproceso complete sus operaciones.

No hay comentarios.:

Publicar un comentario

Dejanos tu comentario para seguir mejorando!

Post Top Ad

Your Ad Spot

Páginas