streamalism.org

1. Introduksjon

I denne veiledningen diskuterer vi Java Kø grensesnitt.

Først skal vi ta en kikke på hva en Kø gjør, og noen av kjernemetodene. Deretter vil vi dykke ned i en rekke implementeringer som Java gir som standard.

Til slutt vil vi snakke om trådsikkerhet før vi pakker det hele sammen.

2. Visualisering av køen

La oss starte med en rask analogi.

Tenk deg at vi nettopp har åpnet vår første virksomhet - en pølsebod. Vi ønsker å betjene våre nye potensielle kunder på en mest mulig effektiv måte for vår lille bedrift; en om gangen. Først ber vi dem om å danne en ordnet linje foran standen vår, med nye kunder som kommer bak. Takket være våre organisasjonsevner kan vi nå distribuere våre smakfulle pølser på en rettferdig måte.

Køer i Java fungerer på en lignende måte. Etter at vi har erklært Kø, vi kan legge til nye elementer på baksiden, og fjerne dem fra fronten.

Faktisk, mest Køer vi møter i Java-arbeid i dette første inn, først ut måte - ofte forkortet til FIFO.

Imidlertid er det ett unntak som vi kommer til å berøre senere.

3. Kjernemetoder

De Kø erklærer en rekke metoder som må kodes av alle implementeringsklasser. La oss skissere noen av de viktigstede nå:

1. by på() - Setter inn et nytt element på Kø
2. avstemming()- Fjerner et element fra fronten av Kø
3. kikke () – Inspiserer elementet foran på Kø, uten å fjerne den

4. AbstractQueue

AbstractQueue er den enklest mulig Kø implementering som Java gir. Det inkluderer en skjelettimplementering av noen av Kø grensesnittets metoder, unntatt by på.

Når vi oppretter en tilpasset kø utvide AbstractQueue klasse,vi må gi en implementeringav by på metode som gjør det ikke tillate innsetting av nullelementer.

I tillegg vi må gi metodene titt, avstemning, størrelse, og java.util‘S iterator.

La oss sette sammen en enkel Kø gjennomføring ved hjelp av AbstractQueue.

La oss først definere klassen vår med a LinkedList å lagre vår Kø er elementer:

offentlig klasse CustomBaeldungQueue utvider AbstractQueue {private LinkedList-elementer; offentlig CustomBaeldungQueue () {this.elements = new LinkedList (); }}

Neste, la oss overstyre de nødvendige metodene og oppgi koden:

@Override public Iterator iterator () {return elements.iterator (); } @ Override public int size () {return elements.size (); } @Override public boolean offer (T t) {if (t == null) returner false; elements.add (t); returner sant; } @ Override offentlig T-avstemning () {Iterator iter = elements.iterator (); T t = iter.next (); hvis (t! = null) {iter.remove (); returnere t; } returner null; } @ Override public T peek () {return elements.getFirst (); }

Utmerket, la oss sjekke at det fungerer med en rask enhetstest:

customQueue.add (7); customQueue.add (5); int først = customQueue.poll (); int sekund = customQueue.poll (); assertEquals (7, først); assertEquals (5, andre);

4. Undergrensesnitt

Generelt sett er Kø grensesnitt er arvet av 3 hovedgrensesnitt. Blokkering av køer, overføringskøer, og Deques.

Sammen er disse 3 grensesnittene implementert av de aller fleste tilgjengelige Java-er Køer. La oss ta en rask titt på hva disse grensesnittene er satt til å gjøre.

4.1. Blokkerer køer

De BlockingQueue grensesnitt støtter tilleggsoperasjoner som tvinger tråder til å vente på Køavhengig av gjeldende tilstand. En tråd kan vent på Kø å være ikke-tom når du prøver å hente, eller at den blir tom når du legger til et nytt element.

Standard Blokkerer køer inkludere LinkedBlockingQueue, SynchronousQueue, og ArrayBlockingQueue.

For mer informasjon, gå over til vår artikkel om Blokkerer køer.

4.2. Overfør køer

De TransferQueue grensesnitt utvider BlockingQueue grensesnitt, men er skreddersydd mot produsent-forbruker mønster. Den styrer informasjonsflyten fra produsent til forbruker, og skaper mottrykk i systemet.

Java leveres med en implementering av TransferQueue grensesnitt, LinkedTransferQueue.

4.3. Deques

Deque er forkortelse for Double-Ended Queue og er analog med en kortstokk - elementene kan tas fra både starten og slutten av Deque. I likhet med det tradisjonelle Kø, de Deque gir metoder for å legge til, hente og kikke på elementer som holdes både øverst og nederst.

For en detaljert guide om hvordan Deque fungerer, sjekk ut vår ArrayDeque artikkel.

5. Prioritetskøer

Vi så tidligere at det meste av Køer som vi kommer over i Java følger FIFO-prinsippet.

Et slikt unntak fra denne regelen er PriorityQueue. Når nye elementer settes inn i PrioritetKø, de bestilles basert på deres naturlige bestilling, eller av en definert Komparator gitt når vi konstruerer PrioritetKø.

La oss se på hvordan dette fungerer med en enkel enhetstest:

PriorityQueue integerQueue = ny PriorityQueue (); integerQueue.add (9); integerQueue.add (2); integerQueue.add (4); int først = heltallQueue.poll (); int sekund = heltallQueue.poll (); int tredje = heltallQueue.poll (); assertEquals (2, først); assertEquals (4, andre); assertEquals (9, tredje);

Til tross for rekkefølgen som våre heltall ble lagt til PrioritetKø, vi kan se det hentingsrekkefølgen endres i henhold til den naturlige rekkefølgen på tallene.

Vi kan se at det samme også gjelder når det brukes Strenger:

PriorityQueue stringQueue = ny PriorityQueue (); stringQueue.add ("blåbær"); stringQueue.add ("eple"); stringQueue.add ("kirsebær"); Streng først = stringQueue.poll (); Streng sekund = stringQueue.poll (); Streng tredje = stringQueue.poll (); assertEquals ("apple", først); assertEquals ("blåbær", andre); assertEquals ("kirsebær", tredje);

6. Trådsikkerhet

Legger til ting i Køer er spesielt nyttig i miljøer med flere tråder. EN Kø kan deles mellom tråder, og brukes til å blokkere fremdrift til plass er tilgjengelig - hjelper oss overvinne noen vanlige problemer med flere tråder.

For eksempel, å skrive til en enkelt disk fra flere tråder skaper ressurskonflikt og kan føre til langsomme skrivetider. Opprette en enkelt forfattertråd med en BlockingQueue kan lindre dette problemet og føre til kraftig forbedrede skrivehastigheter.

Heldigvis tilbyr Java ConcurrentLinkedQueue, ArrayBlockingQueue, og ConcurrentLinkedDeque som er trådsikre og perfekte for programmer med flere tråder.

7. Konklusjon

I denne opplæringen har vi tatt et dypdykk i Java Kø grensesnitt.

For det første, vi utforsket hva en Kø gjør, samt implementeringer som Java gir.

Neste, vi så på en Kø's vanlige FIFO prinsipp, samt PriorityQueue som skiller seg i rekkefølgen.

Til slutt, vi utforsket trådsikkerhet og hvordan Køer kan brukes i et miljø med flere tråder.

Som alltid er koden tilgjengelig på GitHub.