Einführung in die Verwendung von BlockingQueue basierend auf Java

Autor：Eve Cole Aktualisierungszeit：2024-11-18 14:48:02

Seit kurzem pflege ich ein Java-Projekt und in der Gruppe unterhalten wir uns über die Vor- und Nachteile von Java! Leider behaupten einige ultimative Java-Fans immer, dass die Leistung nicht mehr so schlecht ist wie bei C++, und dass viele Standardbibliotheken von Meistern geschrieben wurden, wie stabil sie sind usw. Ich habe es einfach sorgfältig studiert und eine der Anweisungen, die sie mir gegeben haben, war, dass es zur Übermittlung von Nachrichten zwischen Threads ausreicht, BlockingQueue zu verwenden, das in Java gekapselt wurde.

Da dies ausreicht, schreiben wir einfach Code zum Testen: Schreiben Sie einfach ein kleines Programm und führen Sie einige Tests durch:

Kopieren Sie den Codecode wie folgt:

//Standardpaket
import java.util.concurrent.*;

import base.MyRunnable;

Öffentlicher Klassentest
{
public static void main(String[] args)
{
BlockingQueue<Integer> queue = new LinkedBlockingQueue<Integer>();
java.lang.Runnable r = new MyRunnable(queue);
Thread t = neuer Thread(r);
t.start();

while(true)
{
versuchen
{
while(true)
{
for(int i =0;i < 10000;i++)
{
queue.offer(i);
}
}
}
Catch (Ausnahme e)
{
e.printStackTrace();
}
}
}
}

//Pakete, die hinzugefügt werden müssen
Paketbasis;

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

Die öffentliche Klasse MyRunnable implementiert Runnable
{
public MyRunnable(BlockingQueue<Integer> queue)
{
this.queue = Warteschlange;
}
public void run()
{
Datum d = neues Datum();
lange Startzeit = d.getTime();
System.err.println(starttime);
int count = 0;
while(true)
{
versuchen
{
Ganzzahl i = this.queue.poll();
if(i != null)
{
count++;
}
if(count == 100000)
{
Datum e = neues Datum();
lange Endzeit = e.getTime();
System.err.println(count);
System.err.println(endtime);
System.err.print(endtime - starttime);
brechen;
}

}
Catch (Ausnahme e)
{

}
}
}
private BlockingQueue<Integer>-Warteschlange;
}

Die Übertragung von 100.000 Daten dauert auf meiner Testmaschine etwa 50 ms, was nicht schlecht ist! Schauen Sie sich einfach die zugrunde liegende Implementierung von BlockingQueue an

Ich habe im obigen Testcode „offer“ und „poll“ verwendet. Schauen wir uns diese beiden Implementierungsfunktionen an

Kopieren Sie den Codecode wie folgt:

öffentliche E-Umfrage() {
final AtomicInteger count = this.count;
if (count.get() == 0)
null zurückgeben;
E x = null;
int c = -1;
final ReentrantLock takeLock = this.takeLock;
takeLock.lock();
versuchen {
if (count.get() > 0) {
x = extrahieren();
c = count.getAndDecrement();
wenn (c > 1)
notEmpty.signal();
}
} Endlich {
takeLock.unlock();
}
if (c == Kapazität)
signalNotFull();
x zurückgeben;
}

Es ähnelt einem allgemeinen Synchronisationsthread, außer dass ein weiteres Signal hinzugefügt wurde. Beim Erlernen der fortgeschrittenen Programmierung in der Unix-Umgebung habe ich gesehen, dass Bedingungsvariablen für die Synchronisation zwischen Threads verwendet werden und Threads auf wettbewerbsfähige Weise synchronisiert werden können!
Die Implementierung der Umfragefunktion ist ähnlich!

Kopieren Sie den Codecode wie folgt:

öffentliches boolesches Angebot(E e) {
if (e == null) throw new NullPointerException();
final AtomicInteger count = this.count;
if (count.get() == Kapazität)
return false;
int c = -1;
final ReentrantLock putLock = this.putLock;
putLock.lock();
versuchen {
if (count.get() < Kapazität) {
einfügen(e);
c = count.getAndIncrement();
if (c + 1 < Kapazität)
notFull.signal();
}
} Endlich {
putLock.unlock();
}
if(c==0)
signalNotEmpty();
return c >= 0;
}