ArrayBlockingQueue Vs. Beispiel für eine nicht blockierende EvictingQueue von Google Guava

Veröffentlicht: 2020-12-29
ArrayBlockingQueue Vs. Beispiel für eine nicht blockierende EvictingQueue von Google Guava

Nebenläufigkeits-Dienstprogramme sind in Java sehr erstaunlich.

Das Paket java.util.concurrent enthält viele Dienstprogramme, die wir auf verschiedene Arten verwenden können.

In diesem Tutorial gehen wir auf den Unterschied zwischen java.util.concurrent ein. ArrayBlockingQueue und com.google.common.collect. EvictingQueue .

Was ist EvictingQueue?

EvictingQueue ist Teil der Google's Guava library . Dabei handelt es sich um eine non-blocking , bounded (feste Größe) Warteschlange, die automatisch Elemente aus dem head der Warteschlange removes , wenn versucht wird, Elemente zu einer full queue hinzuzufügen.

Wie füge ich die Guava-Bibliothek von Google zu Ihrem Eclipse-Java-Projekt hinzu?

Sie können die folgende Maven-Abhängigkeit zur Datei pom.xml hinzufügen, wenn Sie das Maven-Projekt verwenden. Im Falle eines non-maven Projekts – Sie müssen es von hier herunterladen und die Bibliothek in den Klassenpfad Ihres Projekts aufnehmen.

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

Was ist ArrayBlockingQueue?

Es ist eine blocking , bounded (feste Größe) Warteschlange, die die Elemente intern in einem Array speichert. Es CAN'T unlimited viele Elemente speichern. Diese Warteschlange ordnet Elemente FIFO (first-in-first-out) an.

Read more : Beispiel einer Singleton-Warteschlange

Beginnen wir mit Beispiel

  1. Erstellen Sie eine ArrayBlockingQueue mit der Größe 10
  2. EvictingQueue mit Größe 10 erstellen
  3. Versuchen Sie, der Warteschlange 15 Elemente hinzuzufügen
  4. Für EvictingQueue – es wird kein Fehler ausgegeben
  5. Für ArrayBlockingQueue – es wird der Fehler Queue Full ausgegeben

Erstellen Sie die Klasse 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 ) ;
 
}
 
}
 

Führen Sie dieses Java-Programm einfach als Anwendung in der Eclipse-Konsole oder IntelliJ IDEA aus, und Sie werden das Ergebnis wie dieses sehen.

Konsolenergebnis:

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

Lassen Sie mich wissen, wenn bei der Ausführung des obigen Programms ein Problem auftritt.