ArrayBlockingQueue vs. Ejemplo de EvictingQueue sin bloqueo de Google Guava

Publicado: 2020-12-29
ArrayBlockingQueue vs. Ejemplo de EvictingQueue sin bloqueo de Google Guava

Las utilidades de concurrencia son muy sorprendentes en Java.

El paquete java.util.concurrent contiene muchas utilidades que podemos usar de diferentes maneras.

En este tutorial repasaremos la diferencia entre java.util.concurrent. ArrayBlockingQueue y com.google.common.collect. EvictingQueue .

¿Qué es EvictingQueue?

EvictingQueue es parte de Google's Guava library . Que es una cola bounded non-blocking (tamaño fijo) que removes automáticamente los elementos de la head de la cola cuando se intenta agregar elementos a una full queue .

¿Cómo agregar la biblioteca Guayaba de Google a su proyecto eclipse-java?

Puede agregar la dependencia maven a continuación al archivo pom.xml si está utilizando el proyecto maven. En el caso de un proyecto non-maven , debe descargarlo desde aquí e incluir la biblioteca en el classpath de su proyecto.

1
2
3
4
5
< dependency >
     < groupId > com . google . guava < / groupId >
     < artifactId > guava < / artifactId >
     < version > 30.1.1 - jre < / version >
< / dependency >

¿Qué es ArrayBlockingQueue?

Es una cola de blocking bounded (tamaño fijo) que almacena los elementos internamente en una matriz. CAN'T almacenar cantidades unlimited de elementos. Esta cola ordena los elementos FIFO (first-in-first-out).

Read more : Ejemplo de cola Singleton

Comencemos con el Ejemplo

  1. Crear ArrayBlockingQueue con tamaño 10
  2. Crear EvictingQueue con tamaño 10
  3. Intenta agregar 15 elementos a la cola
  4. Para EvictingQueue: no arrojará ningún error
  5. Para ArrayBlockingQueue: arrojará un error de Queue Full

Crear clase CrunchifyArrayBlockingQueueVsEvictingQueue.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
package crunchify . com . tutorials ;
 
import com . google . common . collect . EvictingQueue ;
 
import java . util . Queue ;
import java . util . concurrent . ArrayBlockingQueue ;
 
/**
* @author Crunchify.com
* ArrayBlockingQueue Vs. Google Guava Non-Blocking EvictingQueue Example
*
*/
 
public class CrunchifyArrayBlockingQueueVsEvictingQueue {
 
private static void CrunchifyArrayBlockingQueue ( ) {
// ArrayBlockingQueue: A bounded blocking queue backed by an array. This queue orders elements FIFO (first-in-first-out).
// The head of the queue is that element that has been on the queue the longest time.
// The tail of the queue is that element that has been on the queue the shortest time.
// New elements are inserted at the tail of the queue, and the queue retrieval operations obtain elements at the head of the queue.
ArrayBlockingQueue < String > crunchifyQueue = new ArrayBlockingQueue < String > (
10 ) ;
 
String crunchifyMsg = "This is ArrayBlockingQueue - by Crunchify" ;
try {
// We are looping for 15 times - Error once queue full
for ( int counter = 1 ; counter < = 15 ; counter ++ ) {
// add(): Inserts the specified element at the tail of this queue if it is possible to do so immediately without exceeding the queue's capacity,
// returning true upon success and throwing an IllegalStateException if this queue is full.
crunchifyQueue . add ( crunchifyMsg + counter ) ;
// size(): Returns the number of elements in this queue.
crunchifyLog ( "ArrayBlockingQueue size: " + crunchifyQueue . size ( ) ) ;
}
} catch ( Exception e ) {
crunchifyLog ( "\nException Occurred: " ) ;
e . printStackTrace ( ) ;
}
 
}
 
public static void main ( String [ ] args ) {
 
// Test EvictingQueue with size 10
CrunchifyEvictingQueue ( ) ;
 
crunchifyLog ( "\n============= New LINE ==============\n" ) ;
 
// Test ArrayBlockingQueue with size 10
CrunchifyArrayBlockingQueue ( ) ;
}
 
private static void CrunchifyEvictingQueue ( ) {
// Queue: A collection designed for holding elements prior to processing. Besides basic Collection operations,
// queues provide additional insertion, extraction, and inspection operations.
// Each of these methods exists in two forms: one throws an exception if the operation fails,
// the other returns a special value (either null or false, depending on the operation).
Queue < String > crunchifyQueue = EvictingQueue . create ( 10 ) ;
 
String crunchifyMsg = "This is EvictingQueue - by Crunchify" ;
try {
// We are looping for 15 times - No error after queue full.
// Instead, it will remove element from queue in FIFO order
for ( int i = 1 ; i < = 15 ; i ++ ) {
// add: Inserts the specified element into this queue if it is possible to do so immediately without violating capacity restrictions,
// returning true upon success and throwing an IllegalStateException if no space is currently available.
crunchifyQueue . add ( crunchifyMsg + i ) ;
 
crunchifyLog ( "EvictingQueue size: " + crunchifyQueue . size ( ) ) ;
}
} catch ( Exception e ) {
crunchifyLog ( "Exception Occurred: " + e ) ;
}
 
}
 
private static void crunchifyLog ( String crunchifyText ) {
System . out . println ( crunchifyText ) ;
 
}
 
}
 

Simplemente ejecute este programa Java como una aplicación en Eclipse Console o IntelliJ IDEA y verá un resultado como este.

Resultado de la consola:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
EvictingQueue size : 1
EvictingQueue size : 2
EvictingQueue size : 3
EvictingQueue size : 4
EvictingQueue size : 5
EvictingQueue size : 6
EvictingQueue size : 7
EvictingQueue size : 8
EvictingQueue size : 9
EvictingQueue size : 10
EvictingQueue size : 10
EvictingQueue size : 10
EvictingQueue size : 10
EvictingQueue size : 10
EvictingQueue size : 10
 
============= New LINE ==============
 
ArrayBlockingQueue size : 1
ArrayBlockingQueue size : 2
ArrayBlockingQueue size : 3
ArrayBlockingQueue size : 4
ArrayBlockingQueue size : 5
ArrayBlockingQueue size : 6
ArrayBlockingQueue size : 7
ArrayBlockingQueue size : 8
ArrayBlockingQueue size : 9
ArrayBlockingQueue size : 10
 
Exception Occurred :
java . lang . IllegalStateException : Queue full
at java . base / java . util . AbstractQueue . add ( AbstractQueue . java : 98 )
at java . base / java . util . concurrent . ArrayBlockingQueue . add ( ArrayBlockingQueue . java : 329 )
at crunchify . com . tutorials . CrunchifyArrayBlockingQueueVsEvictingQueue . CrunchifyArrayBlockingQueue ( CrunchifyArrayBlockingQueueVsEvictingQueue . java : 32 )
at crunchify . com . tutorials . CrunchifyArrayBlockingQueueVsEvictingQueue . main ( CrunchifyArrayBlockingQueueVsEvictingQueue . java : 52 )
 
Process finished with exit code 0

Avíseme si tiene algún problema al ejecutar el programa anterior.