ArrayBlockingQueue Vs. Exemple de file d'attente d'expulsion non bloquante Google Guava

Publié: 2020-12-29
ArrayBlockingQueue Vs. Exemple de file d'attente d'expulsion non bloquante Google Guava

Les utilitaires de concurrence sont très étonnants en Java.

Le package java.util.concurrent contient de nombreux utilitaires que nous pourrions utiliser de différentes manières.

Dans ce tutoriel, nous allons passer en revue la différence entre java.util.concurrent. ArrayBlockingQueue et com.google.common.collect. EvictingQueue .

Qu'est-ce qu'EvictingQueue ?

EvictingQueue fait partie de Google's Guava library . Qui est une file d'attente non-blocking et bounded (taille fixe) qui removes automatiquement les éléments de la head de la file d'attente lors de la tentative d'ajout d'éléments à une file d' full queue .

Comment ajouter la bibliothèque Guava de Google à votre projet eclipse-java ?

Vous pouvez ajouter ci-dessous la dépendance maven au fichier pom.xml si vous utilisez le projet maven. Dans le cas d'un projet non-maven , vous devez le télécharger à partir d'ici et inclure la bibliothèque dans le chemin de classe de votre projet.

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

Qu'est-ce qu'ArrayBlockingQueue ?

Il s'agit d'une file d'attente blocking et bounded (taille fixe) qui stocke les éléments en interne dans un tableau. Il CAN'T stocker des quantités unlimited d'éléments. Cette file d'attente ordonne les éléments FIFO (first-in-first-out).

Read more : Exemple de file d'attente singleton

Commençons par l'exemple

  1. Créer ArrayBlockingQueue avec la taille 10
  2. Créer EvictingQueue avec la taille 10
  3. Essayez d'ajouter 15 éléments à la file d'attente
  4. Pour EvictingQueue - il ne générera aucune erreur
  5. Pour ArrayBlockingQueue - il lancera une erreur de file d' Queue Full

Créer la classe 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 ) ;
 
}
 
}
 

Exécutez simplement ce programme Java en tant qu'application dans la console Eclipse ou IntelliJ IDEA et vous verrez un résultat comme celui-ci.

Résultat console :

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

Faites-moi savoir si vous rencontrez un problème lors de l'exécution du programme ci-dessus.