Gids voor de Java-wachtrijinterface

1. Inleiding

In deze tutorial bespreken we Java's Wachtrij koppel.

Ten eerste zullen we neem een kijkje bij wat een Wachtrij doet, en enkele van de belangrijkste methoden. Vervolgens duiken we in een aantal implementaties die Java standaard levert.

Ten slotte zullen we het hebben over draadveiligheid voordat we alles inpakken.

2. Visualiseren van de wachtrij

Laten we beginnen met een snelle vergelijking.

Stel je voor dat we net ons eerste bedrijf hebben geopend: een hotdogkraam. We willen onze nieuwe potentiële klanten op de meest efficiënte manier van dienst zijn voor onze kleine onderneming; een per keer. Ten eerste vragen we hen een ordelijke rij te vormen voor onze stand, met nieuwe klanten achteraan. Dankzij onze organisatiekwaliteiten kunnen we onze lekkere hotdogs nu op een eerlijke manier verdelen.

Wachtrijen in Java werken op een vergelijkbare manier. Nadat we onze Wachtrij, we kunnen nieuwe elementen aan de achterkant toevoegen en ze aan de voorkant verwijderen.

In feite, meest Wachtrijen we zullen in Java werk tegenkomen in deze first in, first out manier - vaak afgekort tot FIFO.

Er is echter één uitzondering die we later zullen bespreken.

3. Kernmethoden

De Wachtrij verklaart een aantal methoden die moeten worden gecodeerd door alle implementatieklassen. Laten we een paar van de belangrijkste schetsennu:

  1. aanbod() - Voegt een nieuw element in op de Wachtrij
  2. poll ()- Verwijdert een element aan de voorkant van de Wachtrij
  3. kijkje() Inspecteert het element aan de voorkant van het Wachtrij, zonder het te verwijderen

4. AbstractQueue

AbstractQueue is de eenvoudigst mogelijk Wachtrij implementatie die Java biedt. Het bevat een skeletimplementatie van enkele van de Wachtrij interface methoden, met uitzondering van aanbod.

Wanneer we een aangepaste wachtrij maken uitbreiding van de AbstractQueue klasse,we moeten zorgen voor een implementatievan de aanbod methode wat doet niet laat de invoeging van null-elementen toe.

Bovendien, we moeten de methoden bieden kijkje, poll, grootte, en java.util‘S iterator.

Laten we een simpele samenstellen Wachtrij implementatie gebruik makend van AbstractQueue.

Laten we eerst onze klasse definiëren met een LinkedList om onze op te slaan Wachtrij elementen:

openbare klasse CustomBaeldungQueue breidt AbstractQueue {privé LinkedList-elementen uit; openbare CustomBaeldungQueue () {this.elements = nieuwe LinkedList (); }}

Laten we het volgende doen overschrijf de vereiste methoden en geef de code op:

@Override public Iterator iterator () {return elements.iterator (); } @Override public int size () {return elements.size (); } @Override openbare booleaanse aanbieding (T t) {if (t == null) return false; elements.add (t); terugkeer waar; } @Override openbare T poll () {Iterator iter = elements.iterator (); T t = iter.next (); if (t! = null) {iter.remove (); terug t; } retourneer null; } @Override public T peek () {return elements.getFirst (); }

Uitstekend, laten we eens kijken of het werkt met een snelle unit-test:

customQueue.add (7); customQueue.add (5); int eerste = customQueue.poll (); int tweede = customQueue.poll (); assertEquals (7, eerste); assertEquals (5, tweede);

4. Subinterfaces

Over het algemeen is het Wachtrij interface wordt overgenomen door 3 belangrijkste subinterfaces. Wachtrijen blokkeren, wachtrijen overdragen, en Deques.

Samen worden deze 3 interfaces geïmplementeerd door de overgrote meerderheid van de beschikbare Java's Wachtrijen. Laten we snel kijken wat deze interfaces zijn bedoeld om te doen.

4.1. Wachtrijen blokkeren

De BlockingQueue koppel ondersteunt aanvullende bewerkingen die threads dwingen te wachten op het Wachtrijafhankelijk van de huidige staat. Een draad kan wacht op de Wachtrij om niet-leeg te zijn bij een poging tot ophalen, of om leeg te worden bij het toevoegen een nieuw element.

Standaard Wachtrijen blokkeren omvatten LinkedBlockingQueue, SynchronousQueue, en ArrayBlockingQueue.

Ga voor meer informatie naar ons artikel over Wachtrijen blokkeren.

4.2. Wachtrijen overdragen

De TransferQueue interface breidt de BlockingQueue interface maar is afgestemd op het producent-consument patroon. Het regelt de informatiestroom van producent naar consument, waardoor tegendruk in het systeem ontstaat.

Java wordt geleverd met één implementatie van het TransferQueue koppel, LinkedTransferQueue.

4.3. Deques

Deque is een afkorting voor Duit-E.nded Wachtrijue en is analoog aan een pak kaarten - elementen kunnen zowel aan het begin als aan het einde van de Deque. Net als het traditionele Wachtrij, de Deque biedt methoden om elementen aan de boven- en onderkant toe te voegen, op te halen en te bekijken.

Voor een gedetailleerde gids over hoe het Deque werkt, bekijk onze ArrayDeque artikel.

5. Prioriteitswachtrijen

We zagen eerder dat de meeste Wachtrijen die we tegenkomen in Java volgen het FIFO-principe.

Een dergelijke uitzondering op deze regel is de Prioriteits-rij. Wanneer nieuwe elementen worden ingevoegd in het PrioriteitWachtrij, ze zijn geordend op basis van hun natuurlijke ordening, of door een gedefinieerd Comparator verstrekt wanneer we de PrioriteitWachtrij.

Laten we eens kijken hoe dit werkt met een eenvoudige unit-test:

PriorityQueue integerQueue = nieuwe PriorityQueue (); integerQueue.add (9); integerQueue.add (2); integerQueue.add (4); int eerste = integerQueue.poll (); int tweede = integerQueue.poll (); int derde = integerQueue.poll (); assertEquals (2, eerste); assertEquals (4, tweede); assertEquals (9, derde);

Ondanks de volgorde waarin onze gehele getallen zijn toegevoegd aan de PrioriteitWachtrij, dat kunnen we zien de ophaalvolgorde wordt gewijzigd volgens de natuurlijke volgorde van de nummers.

We kunnen zien dat hetzelfde ook geldt wanneer het wordt toegepast Snaren:

PriorityQueue stringQueue = nieuwe PriorityQueue (); stringQueue.add ("bosbes"); stringQueue.add ("appel"); stringQueue.add ("cherry"); String eerste = stringQueue.poll (); String tweede = stringQueue.poll (); String derde = stringQueue.poll (); assertEquals ("appel", eerst); assertEquals ("bosbes", tweede); assertEquals ("cherry", derde);

6. Draadveiligheid

Items toevoegen aan Wachtrijen is vooral handig in omgevingen met meerdere threads. EEN Wachtrij kunnen worden gedeeld door threads en worden gebruikt om de voortgang te blokkeren totdat er ruimte beschikbaar is - ons helpen enkele veelvoorkomende problemen met meerdere threads oplossen.

Het schrijven naar een enkele schijf vanuit meerdere threads leidt bijvoorbeeld tot conflicten tussen bronnen en kan leiden tot langzame schrijftijden. Een enkele schrijver-thread maken met een BlockingQueue kan dit probleem verlichten en tot sterk verbeterde schrijfsnelheden leiden.

Gelukkig biedt Java ConcurrentLinkedQueue, ArrayBlockingQueue, en ConcurrentLinkedDeque die draadveilig zijn en perfect voor multi-threaded programma's.

7. Conclusie

In deze tutorial hebben we een diepe duik genomen in Java Wachtrij koppel.

Ten eerste wij onderzocht wat een Wachtrij doet, net als de implementaties die Java biedt.

Vervolgens we keek naar een Wachtrij's gebruikelijke FIFO-principe, evenals het Prioriteits-rij die verschilt in zijn volgorde.

Eindelijk, we onderzocht draadveiligheid en hoe Wachtrijen kan worden gebruikt in een omgeving met meerdere threads.

Zoals altijd is de code beschikbaar op GitHub.