Introduction à l'utilisation de BlockingQueue basé sur Java

Auteur：Eve Cole Date de mise à jour：2024-11-18 14:48:02

Récemment, je maintiens un projet Java, et dans le groupe nous discutons des avantages et des inconvénients de Java ! Malheureusement, certains fans ultimes de Java affirment toujours que les performances ne sont plus aussi mauvaises que celles du C++, et que de nombreuses bibliothèques standard sont écrites par des maîtres, quelle est leur stabilité, etc. Je l'ai simplement étudié attentivement, et l'une des instructions qu'ils m'ont données était que pour transmettre des messages entre les threads, il suffisait d'utiliser BlockingQueue, qui a été encapsulé en Java.

Puisque c'est suffisant, écrivons du code pour le tester. Écrivons simplement un petit programme et faisons quelques tests :

Copiez le code comme suit :

//Package par défaut
importer java.util.concurrent.* ;

importer base.MyRunnable ;

Test de classe publique
{
public static void main (String[] arguments)
{
BlockingQueue<Integer> queue = new LinkedBlockingQueue<Integer>();
java.lang.Runnable r = new MyRunnable(file d'attente);
Fil t = nouveau fil(r);
t.start();

tandis que (vrai)
{
essayer
{
tandis que (vrai)
{
pour (int je =0;i < 10000;i++)
{
file d'attente.offre(i);
}
}
}
attraper (exception e)
{
e.printStackTrace();
}
}
}
}

//Packages qui doivent être ajoutés
base de paquet ;

importer java.lang.Runnable ;
importer java.util.concurrent.* ;
importer java.util.* ;

classe publique MyRunnable implémente Runnable
{
public MyRunnable (file d'attente BlockingQueue<Integer>)
{
this.queue = file d'attente ;
}
exécution publique vide()
{
Date d = nouvelle Date();
heure de début longue = d.getTime();
System.err.println(heure de début);
nombre entier = 0 ;
tandis que (vrai)
{
essayer
{
Entier i = this.queue.poll();
si(i != nul)
{
compte++;
}
si (compte == 100 000)
{
Date e = nouvelle Date();
heure de fin longue = e.getTime();
System.err.println(count);
System.err.println(heure de fin);
System.err.print (heure de fin - heure de début);
casser;
}

}
attraper (exception e)
{

}
}
}
file d'attente privée BlockingQueue<Integer> ;
}

Pour transférer 100 000 données, il faut environ 50 ms sur ma machine de test, ce qui n'est pas mal ! Jetez simplement un œil à l’implémentation sous-jacente de BlockingQueue

J'ai utilisé offer et poll dans le code de test ci-dessus. Jetons un coup d'œil à ces deux fonctions d'implémentation. La première est l'offre.

Copiez le code comme suit :

sondage public E() {
nombre final d'AtomicInteger = this.count ;
si (count.get() == 0)
renvoie null ;
E x = nul ;
int c = -1 ;
final ReentrantLock takeLock = this.takeLock;
takeLock.lock();
essayer {
si (count.get() > 0) {
x = extraire();
c = count.getAndDecrement();
si (c > 1)
notEmpty.signal();
}
} enfin {
takeLock.unlock();
}
si (c == capacité)
signalNotFull();
renvoyer x ;
}

C'est similaire à un thread de synchronisation général, sauf qu'un signal supplémentaire est ajouté. Lors de l'apprentissage de la programmation avancée dans l'environnement Unix, j'ai vu que les variables de condition sont utilisées pour la synchronisation entre les threads, et les threads peuvent être synchronisés de manière compétitive !
La mise en œuvre de la fonction sondage est similaire !

Copiez le code comme suit :

offre booléenne publique(E e) {
if (e == null) throw new NullPointerException();
nombre final d'AtomicInteger = this.count ;
if (count.get() == capacité)
renvoie faux ;
int c = -1 ;
final ReentrantLock putLock = this.putLock;
putLock.lock();
essayer {
if (count.get() < capacité) {
insérer(e);
c = count.getAndIncrement();
si (c + 1 < capacité)
notFull.signal();
}
} enfin {
putLock.unlock();
}
si(c==0)
signalNotEmpty();
retourner c >= 0 ;
}