Introduction à Big Queue

1. Vue d'ensemble

Dans ce didacticiel, nous allons jeter un rapide coup d'œil à Big Queue, une implémentation Java d'une file d'attente persistante.

Nous parlerons un peu de son architecture, puis nous apprendrons à l'utiliser à travers des exemples rapides et pratiques.

2. Utilisation

Nous devrons ajouter la dépendance bigqueue à notre projet:

 com.leansoft bigqueue 0.7.0 

Nous devons également ajouter son référentiel:

 github.release.repo //raw.github.com/bulldog2011/bulldog-repo/master/repo/releases/ 

Si nous avons l'habitude de travailler avec des files d'attente de base, ce sera un jeu d'enfant de s'adapter à Big Queue car son API est assez similaire.

2.1. Initialisation

Nous pouvons initialiser notre file d'attente en appelant simplement son constructeur:

@Before public void setup() { String queueDir = System.getProperty("user.home"); String queueName = "baeldung-queue"; bigQueue = new BigQueueImpl(queueDir, queueName); }

Le premier argument est le répertoire personnel de notre file d'attente.

Le deuxième argument représente le nom de notre file d'attente. Cela créera un dossier dans le répertoire personnel de notre file d'attente où nous pourrons conserver les données.

Nous devons nous rappeler de fermer notre file d'attente lorsque nous avons terminé pour éviter les fuites de mémoire:

bigQueue.close();

2.2. Insertion

Nous pouvons ajouter des éléments à la queue en appelant simplement la méthode de mise en file d'attente :

@Test public void whenAddingRecords_ThenTheSizeIsCorrect() { for (int i = 1; i <= 100; i++) { bigQueue.enqueue(String.valueOf(i).getBytes()); } assertEquals(100, bigQueue.size()); }

Nous devons noter que Big Queue ne prend en charge que le type de données byte [] , nous sommes donc responsables de la sérialisation de nos enregistrements lors de leur insertion.

2.3. En train de lire

Comme on pouvait s'y attendre, la lecture des données est tout aussi simple en utilisant la méthode dequeue :

@Test public void whenAddingRecords_ThenTheyCanBeRetrieved() { bigQueue.enqueue(String.valueOf("new_record").getBytes()); String record = new String(bigQueue.dequeue()); assertEquals("new_record", record); }

Nous devons également veiller à désérialiser correctement nos données lors de la lecture.

La lecture à partir d'une file d'attente vide lève une NullPointerException .

Nous devons vérifier qu'il existe des valeurs dans notre file d'attente à l'aide de la méthode isEmpty :

if(!bigQueue.isEmpty()){ // read }

Pour vider notre file d'attente sans avoir à parcourir chaque enregistrement, nous pouvons utiliser la méthode removeAll :

bigQueue.removeAll();

2.4. Jetant un œil

En jetant un œil, nous lisons simplement un enregistrement sans le consommer:

@Test public void whenPeekingRecords_ThenSizeDoesntChange() { for (int i = 1; i <= 100; i++) { bigQueue.enqueue(String.valueOf(i).getBytes()); } String firstRecord = new String(bigQueue.peek()); assertEquals("1", firstRecord); assertEquals(100, bigQueue.size()); }

2.5. Suppression des enregistrements consommés

Lorsque nous appelons la méthode dequeue , les enregistrements sont supprimés de notre file d'attente, mais ils restent persistants sur le disque.

Cela pourrait potentiellement remplir notre disque de données inutiles.

Heureusement, nous pouvons supprimer les enregistrements consommés en utilisant la méthode gc :

bigQueue.gc();

Tout comme le garbage collector de Java nettoie les objets non référencés du tas, gc nettoie les enregistrements consommés de notre disque.

3. Architecture et fonctionnalités

Ce qui est intéressant à propos de Big Queue, c'est le fait que sa base de code est extrêmement petite - seulement 12 fichiers source occupant environ 20 Ko d'espace disque.

À un niveau élevé, il s'agit simplement d'une file d'attente persistante qui excelle dans la gestion de grandes quantités de données.

3.1. Gestion de grandes quantités de données

La taille de la file d'attente n'est limitée que par notre espace disque total disponible. Chaque enregistrement de notre file d'attente est conservé sur le disque, afin d'être résistant aux pannes.

Notre goulot d'étranglement sera les E / S de disque, ce qui signifie qu'un SSD améliorera considérablement le débit moyen sur un disque dur.

3.2. Accès aux données extrêmement rapide

Si nous jetons un œil à son code source, nous remarquerons que la file d'attente est sauvegardée par un fichier mappé en mémoire. La partie accessible de notre file d'attente (la tête) est conservée dans la RAM, l'accès aux enregistrements sera donc extrêmement rapide.

Même si notre file d'attente devenait extrêmement volumineuse et occuperait des téraoctets d'espace disque, nous serions toujours en mesure de lire les données avec une complexité temporelle O (1).

Si nous avons besoin de lire beaucoup de messages et que la vitesse est une préoccupation essentielle, nous devrions envisager d'utiliser un SSD sur un disque dur, car le déplacement des données du disque vers la mémoire serait beaucoup plus rapide.

3.3. Avantages

Un grand avantage est sa capacité à croître de très grande taille. Nous pouvons l'adapter à l'infini théorique en ajoutant simplement plus de stockage, d'où son nom «Big».

Dans un environnement simultané, Big Queue peut produire et consommer environ 166 Mo / s de données sur une machine de base.

Si la taille moyenne de nos messages est de 1 Ko, il peut traiter 166 000 messages par seconde.

Il peut aller jusqu'à 333k messages par seconde dans un environnement à thread unique - assez impressionnant!

3.4. Désavantages

Nos messages restent conservés sur le disque, même après les avoir consommés, nous devons donc nous occuper des données de collecte des ordures lorsque nous n'en avons plus besoin.

Nous sommes également responsables de la sérialisation et de la désérialisation de nos messages.

4. Conclusion

Dans ce tutoriel rapide, nous avons découvert Big Queue et comment nous pouvons l'utiliser comme file d'attente évolutive et persistante.

Comme toujours, le code est disponible sur Github.