implementieren Sie-Ihre-eigenen-blocking queue in java

Ich weiß, das ist eine alte Frage, die von jetzt, aber nach dem Lesen der Frage und Antworten konnte ich nicht helfen, mein selbst, ich hoffe, Sie finden diese nützlich.

In Bezug auf die überprüfung, ob die queue tatsächlich voll ist oder leer vor, bevor er die anderen wartenden threads, Sie sind nicht etwas, was sowohl die Methoden put (T t) und T get() sind beide synchronized Methoden, was bedeutet, dass nur ein thread kann geben Sie eine der folgenden Methoden, zu einer Zeit, aber das wird nicht verhindern, dass Sie arbeiten zusammen, so dass, wenn ein thread-ein eingegeben hat put (T t) Methode, die ein anderer thread b kann immer noch geben Sie und starten Sie das ausführen der Anweisungen in T get() Methode, bevor thread a beendet wurde put (T t), und so double-checking design machen die Entwickler fühlen sich ein wenig sicherer, weil man nicht wissen kann, wenn zukünftige cpu-Kontextwechsel, wenn oder wenn geschehen wird.

Besser und eine weitere empfohlene Methode ist die Verwendung Reentrant Locks und Conditions:

//Ich habe bearbeitet den Quellcode von diesem link

Condition isFullCondition;
Condition isEmptyCondition;
Lock lock;

public BQueue() {
    this(Integer.MAX_VALUE);
}

public BQueue(int limit) {
    this.limit = limit;
    lock = new ReentrantLock();
    isFullCondition = lock.newCondition();
    isEmptyCondition = lock.newCondition();
}

public void put (T t) {
    lock.lock();
    try {
       while (isFull()) {
            try {
                isFullCondition.await();
            } catch (InterruptedException ex) {}
        }
        q.add(t);
        isEmptyCondition.signalAll();
    } finally {
        lock.unlock();
    }
 }

public T get() {
    T t = null;
    lock.lock();
    try {
        while (isEmpty()) {
            try {
                isEmptyCondition.await();
            } catch (InterruptedException ex) {}
        }
        t = q.poll();
        isFullCondition.signalAll();
    } finally { 
        lock.unlock();
    }
    return t;
}

Mit diesem Ansatz gibt es keine Notwendigkeit für double checking, weil die lock Objekt ist geteilt zwischen den beiden Methoden, was bedeutet, dass nur ein thread a oder b eingeben können, diese Methoden zu einer Zeit, im Gegensatz zu synchronisierten Methoden, die schafft verschiedenen Monitoren, und nur diese threads warten, weil die Warteschlange voll ist, werden Sie benachrichtigt werden, wenn es mehr Raum, und das gleiche gilt für threads warten, weil die Warteschlange leer ist, führt dies zu einer besseren cpu-Auslastung.
finden Sie weitere detaillierte Beispiele mit source-code hier

Der Grund, warum die Autoren verwendeten notifyAll() ist einfach: Sie hatten keine Ahnung, ob oder nicht es notwendig war, und so entschieden Sie sich für die "sicherere" option.

Im obigen Beispiel würde es ausreichen, rufen Sie notify() als für jedes einzelne element Hinzugefügt, nur einen einzigen thread warten, bedient werden können, unter allen Umständen.

Dies wird noch deutlicher, wenn in Ihrer Warteschlange hat die option zum hinzufügen mehrerer Elemente in einem Schritt wie addAll(Collection<T> list) wie in diesem Fall mehr als ein thread wartet auf eine leere Liste bedient werden konnten, um genau zu sein: es werden so viele threads wie die Elemente Hinzugefügt wurden.

Den notifyAll() jedoch führt zu einem Mehraufwand in den speziellen single-element-Fall, wie viele threads geweckt unnötig und müssen deshalb eingeschläfert werden wieder blockiert-Warteschlange-Zugang in der Zwischenzeit. So ersetzt notifyAll() mit notify() würde die Geschwindigkeit verbessert in diesem speziellen Fall.

Aber dann nicht mit warten/Benachrichtigen und synchronisiert, sondern verwenden das concurrent-Paket würde die Erhöhung der Geschwindigkeit durch eine Menge mehr als jeder smart-wait/notify-Implementierung könnte jemals.