BlockingQueue ja Sen Toteutukset
Perus BlockingQueue-toteutukset
Emme käy läpi jokaista toteutusta yksityiskohtaisesti, sillä se veisi paljon aikaa, eikä todennäköisesti kaikkia tarvita. Käsittelen yleisiä periaatteita ja mitä konstruktoreita niillä on.
Esimerkki tosielämästä
Kuvittele tehdas, jossa yksi säie, tuottaja, valmistaa osia ja toinen säie, kuluttaja, käsittelee niitä. Tuottaja asettaa osat jonoon, kun taas kuluttaja hakee ja käsittelee ne jonosta. Jos jonossa ei ole osia, kuluttaja odottaa, että tuottaja lisää niitä. Vastaavasti, jos jono on täynnä, tuottaja odottaa, että kuluttaja vapauttaa tilaa.
Hieman alempana toteutamme tämän tehtävän koodissa.
Erot muihin kokoelmatyyppeihin
BlockingQueue tarjoaa automaattisen synkronoinnin, halliten säikeiden pääsyä jonoon ilman manuaalista synkronointia. Se tukee myös blokkaavia operaatioita lisäämiselle ja hakemiselle, mikä on poikkeavaa verrattuna muihin kokoelmiin kuten ArrayList tai LinkedList.
BlockingQueue-toteutukset
ArrayBlockingQueue: Kokorajoitettu jono, joka käyttää taulukkoa alkioiden tallentamiseen.
Main.java
123456789// Constructor with fixed capacity BlockingQueue<String> queue1 = new ArrayBlockingQueue<>(5); // Constructor with fixed capacity and fair access BlockingQueue<String> queue2 = new ArrayBlockingQueue<>(5, true); // Constructor with fixed capacity and initial collection of elements Collection<String> initialElements = java.util.Arrays.asList("One", "Two", "Three"); BlockingQueue<String> queue3 = new ArrayBlockingQueue<>(5, false, initialElements);
true parametri mahdollistaa oikeudenmukaisen käyttöpolitiikan tarjoamalla säikeille pääsyn FIFO-järjestyksessä.
LinkedBlockingQueueue: Jonorakenne, joka perustuu linkitettyihin solmuihin ja voi olla rajoitettu tai rajoittamaton.
Main.java
123456789// Constructor without capacity bounds BlockingQueue<String> queue1 = new LinkedBlockingQueue<>(); // Constructor with fixed capacity BlockingQueue<String> queue2 = new LinkedBlockingQueue<>(5); // Constructor with initial collection of elements Collection<String> initialElements = java.util.Arrays.asList("One", "Two", "Three"); BlockingQueue<String> queue3 = new LinkedBlockingQueue<>(initialElements);
PriorityBlockingQueue: Rajoittamaton priorisoitu jono, jossa alkioiden noutaminen tapahtuu niiden luonnollisen järjestyksen tai määritetyn vertailijan mukaan.
Main.java
12345678910111213// Constructor without initial capacity (default is 11) BlockingQueue<Integer> queue1 = new PriorityBlockingQueue<>(); // Constructor with initial capacity BlockingQueue<Integer> queue2 = new PriorityBlockingQueue<>(5); // Constructor with initial capacity and comparator Comparator<Integer> comparator = Integer::compareTo; BlockingQueue<Integer> queue3 = new PriorityBlockingQueue<>(5, comparator); // Constructor with initial collection of elements Collection<Integer> initialElements = java.util.Arrays.asList(1, 3, 2); BlockingQueue<Integer> queue4 = new PriorityBlockingQueue<>(initialElements)
DelayQueue: Viivästetty jono, josta alkioita voidaan hakea vasta viiveen umpeuduttua.
DelayedElement.java
DelayQueueConstructors.java
123456789101112131415161718class DelayedElement implements Delayed { private final long expirationTime; // The time when the element will be available public DelayedElement(long delay, TimeUnit unit) { this.expirationTime = System.currentTimeMillis() + unit.toMillis(delay); } @Override public long getDelay(TimeUnit unit) { long delay = expirationTime - System.currentTimeMillis(); // Calculate the remaining delay return unit.convert(delay, TimeUnit.MILLISECONDS); // Convert the delay to the specified time unit } @Override public int compareTo(Delayed o) { return Long.compare(this.expirationTime, ((DelayedElement) o).expirationTime); } }
Tämä koodi havainnollistaa DelayedElement-luokan käyttöä, joka toteuttaa Delayed-rajapinnan, sekä DelayQueue-viivejonon käyttöä Javassa. DelayedElement-luokka määrittelee getDelay-metodin jäljellä olevan viiveajan laskemiseen ja compareTo-metodin olioiden vertailuun viiveen päättymisajan perusteella.
main-metodi luo kaksi jonoa: queue1, joka on tyhjä viivejono, ja queue2, joka alustetaan alkioilla, joiden viiveet ovat 5 ja 1 sekuntia.
DelayQueueue-jonon alkiot tulevat saataville haettavaksi vasta määritellyn viiveajan kuluttua.
SynchronousQueueue: Jono ilman kapasiteettia, jossa jokaisen lisäysoperaation on odotettava vastaavaa poisto-operaatiota ja päinvastoin.
Main.java
12345// Constructor without fair access BlockingQueue<String> queue1 = new SynchronousQueue<>(); // Constructor with fair access BlockingQueue<String> queue2 = new SynchronousQueue<>(true);
BlockingQueue:n pääasialliset metodit:
Alkioiden lisääminen:
void put(E e) metodi lisää alkion jonoon, estäen säikeen jos jono on täynnä. Vaihtoehtoisesti boolean offer(E e, long timeout, TimeUnit unit) metodi yrittää lisätä alkion jonoon, odottaen määritetyn ajan jos jono on täynnä.
Main.java
1234567891011121314151617public class BlockingQueueExample { public static void main(String[] args) { BlockingQueue<String> queue = new ArrayBlockingQueue<>(2); try { queue.put("Element 1"); // Insert the first element, no blocking. queue.put("Element 2"); // Insert the second element, no blocking. // Try to add the third element with a 2-second timeout. // Since the queue is full, it will wait for 2 seconds. boolean success = queue.offer("Element 3", 2, TimeUnit.SECONDS); } catch (InterruptedException e) { e.printStackTrace(); } } }
Tämä esimerkki havainnollistaa kahden alkion lisäämistä BlockingQueue-jonoon ilman estoa, minkä jälkeen yritetään lisätä kolmas alkio käyttäen 2 sekunnin aikakatkaisua offer()-metodilla, joka odottaa, jos jono on täynnä.
Alkion noutaminen:
E take() metodi hakee ja palauttaa alkion jonosta, estäen säikeen jos jono on tyhjä. Vaihtoehtoisesti E poll(long timeout, TimeUnit unit) metodi yrittää hakea alkion jonosta, odottaen määritetyn ajan jos jono on tyhjä.
Main.java
1234567891011121314151617181920212223public class BlockingQueueRetrievalExample { public static void main(String[] args) { BlockingQueue<String> queue = new ArrayBlockingQueue<>(2); try { // Adding elements to the queue queue.put("Element 1"); queue.put("Element 2"); // Retrieve and remove the first element, no blocking since the queue is not empty String item1 = queue.take(); // Returns "Element 1" // Attempt to retrieve and remove the next element with a 2-second timeout String item2 = queue.poll(2, TimeUnit.SECONDS); // Returns "Element 2" // Attempt to retrieve an element when the queue is empty, this will block for 2 seconds String item3 = queue.poll(2, TimeUnit.SECONDS); // Returns `null` after timeout } catch (InterruptedException e) { e.printStackTrace(); } } }
Tämä koodi lisää kaksi alkiota BlockingQueue-jonoon, hakee ja poistaa ensimmäisen alkion välittömästi, yrittää hakea seuraavan alkion 2 sekunnin aikakatkaisulla ja lopuksi yrittää hakea alkiota tyhjästä jonosta, mikä johtaa null-arvoon aikakatkaisun jälkeen.
Alkioiden tarkistaminen ja poistaminen:
boolean remove(Object o) metodi poistaa määritetyn alkion jonosta, jos se on läsnä. Vastaavasti boolean contains(Object o) metodi tarkistaa, onko määritetty alkio jonossa ilman, että sitä poistetaan.
Main.java
1234567891011121314151617181920212223242526public class BlockingQueueCheckRemoveExample { public static void main(String[] args) { BlockingQueue<String> queue = new ArrayBlockingQueue<>(2); try { // Adding elements to the queue queue.put("Element 1"); queue.put("Element 2"); // Check if "Element 1" is in the queue, should return `true` boolean containsElement1 = queue.contains("Element 1"); // true // Remove "Element 1" from the queue, should return `true` boolean removedElement1 = queue.remove("Element 1"); // true // Check if "Element 1" is still in the queue, should return `false` boolean containsElement1AfterRemoval = queue.contains("Element 1"); // false // Try to remove an element that is not in the queue, should return `false` boolean removedElement3 = queue.remove("Element 3"); // false } catch (InterruptedException e) { e.printStackTrace(); } } }
Tämä koodi lisää kaksi alkiota BlockingQueue-jonoon, tarkistaa "Element 1" -alkion olemassaolon, poistaa sen, tarkistaa uudelleen varmistaakseen poiston ja yrittää poistaa olemattoman alkion.
Jonon tilan tarkastelu:
int size() metodi palauttaa jonossa olevien alkioiden määrän. Selvittääksesi, onko jono tyhjä, voit käyttää boolean isEmpty() metodia, joka tarkistaa, ettei jonossa ole alkioita. Kiinteän kapasiteetin jonoissa int remainingCapacity() metodi ilmoittaa jonoon jäljellä olevien vapaiden paikkojen määrän.
Main.java
123456789101112131415161718192021222324252627282930public class BlockingQueueCapacityExample { public static void main(String[] args) { BlockingQueue<String> queue = new ArrayBlockingQueue<>(3); try { // Adding elements to the queue queue.put("Element 1"); queue.put("Element 2"); // Get the number of elements in the queue int currentSize = queue.size(); // 2 // Check if the queue is empty boolean isQueueEmpty = queue.isEmpty(); // false // Get the remaining capacity in the queue int remainingSpace = queue.remainingCapacity(); // 1 // Add another element to fill the queue queue.put("Element 3"); // Check the size and remaining capacity after adding the third element currentSize = queue.size(); // 3 remainingSpace = queue.remainingCapacity(); // 0 } catch (InterruptedException e) { e.printStackTrace(); } } }
Tämä koodi lisää alkioita BlockingQueue-jonoon, tarkistaa nykyisen koon, varmistaa onko jono tyhjä, ja määrittää jäljellä olevan kapasiteetin, minkä jälkeen se päivittää nämä arvot täytettyään jonon kokonaan.
Reaaliaikaisen esimerkin toteutus koodissa
😭 Rajoitukset
Yksi keskeinen rajoitus on suorituskyky: lukitusoperaatioiden vuoksi suorituskyky voi heikentyä verrattuna ei-synkronoituun kokoelmaan. Lisäksi resurssit voivat muodostua ongelmaksi, sillä suuret jonot vaativat enemmän muistia ja suoritinaikaa lukkojen ja synkronointiprosessien hallintaan.
💪 Edut
Positiivisena puolena järjestelmä on turvallinen monisäikeisessä ympäristössä, tarjoten turvallisen viestinnän säikeiden välillä ilman manuaalista synkronoinnin hallintaa. Se myös yksinkertaistaa koodia välttämällä monimutkaisia synkronointi- ja estorakenteita. Lisäksi eri BlockingQueue-toteutusten joustavuus mahdollistaa niiden soveltamisen erilaisiin käyttötarkoituksiin.
1. Mikä on BlockingQueue Java-ohjelmoinnissa?
2. Mitkä ovat BlockingQueue:n pääasialliset säiettä estävät metodit?
3. Mihin BlockingQueue on hyödyllinen monisäikeisissä sovelluksissa?
Kiitos palautteestasi!
Kysy tekoälyä
Kysy tekoälyä
Kysy mitä tahansa tai kokeile jotakin ehdotetuista kysymyksistä aloittaaksesi keskustelumme
What are the main differences between the BlockingQueue implementations?
Can you explain how the DelayQueue works in more detail?
How does the producer-consumer example work in code?
Awesome!
Completion rate improved to 3.33BlockingQueue ja Sen Toteutukset
Pyyhkäise näyttääksesi valikon
Perus BlockingQueue-toteutukset
Emme käy läpi jokaista toteutusta yksityiskohtaisesti, sillä se veisi paljon aikaa, eikä todennäköisesti kaikkia tarvita. Käsittelen yleisiä periaatteita ja mitä konstruktoreita niillä on.
Esimerkki tosielämästä
Kuvittele tehdas, jossa yksi säie, tuottaja, valmistaa osia ja toinen säie, kuluttaja, käsittelee niitä. Tuottaja asettaa osat jonoon, kun taas kuluttaja hakee ja käsittelee ne jonosta. Jos jonossa ei ole osia, kuluttaja odottaa, että tuottaja lisää niitä. Vastaavasti, jos jono on täynnä, tuottaja odottaa, että kuluttaja vapauttaa tilaa.
Hieman alempana toteutamme tämän tehtävän koodissa.
Erot muihin kokoelmatyyppeihin
BlockingQueue tarjoaa automaattisen synkronoinnin, halliten säikeiden pääsyä jonoon ilman manuaalista synkronointia. Se tukee myös blokkaavia operaatioita lisäämiselle ja hakemiselle, mikä on poikkeavaa verrattuna muihin kokoelmiin kuten ArrayList tai LinkedList.
BlockingQueue-toteutukset
ArrayBlockingQueue: Kokorajoitettu jono, joka käyttää taulukkoa alkioiden tallentamiseen.
Main.java
123456789// Constructor with fixed capacity BlockingQueue<String> queue1 = new ArrayBlockingQueue<>(5); // Constructor with fixed capacity and fair access BlockingQueue<String> queue2 = new ArrayBlockingQueue<>(5, true); // Constructor with fixed capacity and initial collection of elements Collection<String> initialElements = java.util.Arrays.asList("One", "Two", "Three"); BlockingQueue<String> queue3 = new ArrayBlockingQueue<>(5, false, initialElements);
true parametri mahdollistaa oikeudenmukaisen käyttöpolitiikan tarjoamalla säikeille pääsyn FIFO-järjestyksessä.
LinkedBlockingQueueue: Jonorakenne, joka perustuu linkitettyihin solmuihin ja voi olla rajoitettu tai rajoittamaton.
Main.java
123456789// Constructor without capacity bounds BlockingQueue<String> queue1 = new LinkedBlockingQueue<>(); // Constructor with fixed capacity BlockingQueue<String> queue2 = new LinkedBlockingQueue<>(5); // Constructor with initial collection of elements Collection<String> initialElements = java.util.Arrays.asList("One", "Two", "Three"); BlockingQueue<String> queue3 = new LinkedBlockingQueue<>(initialElements);
PriorityBlockingQueue: Rajoittamaton priorisoitu jono, jossa alkioiden noutaminen tapahtuu niiden luonnollisen järjestyksen tai määritetyn vertailijan mukaan.
Main.java
12345678910111213// Constructor without initial capacity (default is 11) BlockingQueue<Integer> queue1 = new PriorityBlockingQueue<>(); // Constructor with initial capacity BlockingQueue<Integer> queue2 = new PriorityBlockingQueue<>(5); // Constructor with initial capacity and comparator Comparator<Integer> comparator = Integer::compareTo; BlockingQueue<Integer> queue3 = new PriorityBlockingQueue<>(5, comparator); // Constructor with initial collection of elements Collection<Integer> initialElements = java.util.Arrays.asList(1, 3, 2); BlockingQueue<Integer> queue4 = new PriorityBlockingQueue<>(initialElements)
DelayQueue: Viivästetty jono, josta alkioita voidaan hakea vasta viiveen umpeuduttua.
DelayedElement.java
DelayQueueConstructors.java
123456789101112131415161718class DelayedElement implements Delayed { private final long expirationTime; // The time when the element will be available public DelayedElement(long delay, TimeUnit unit) { this.expirationTime = System.currentTimeMillis() + unit.toMillis(delay); } @Override public long getDelay(TimeUnit unit) { long delay = expirationTime - System.currentTimeMillis(); // Calculate the remaining delay return unit.convert(delay, TimeUnit.MILLISECONDS); // Convert the delay to the specified time unit } @Override public int compareTo(Delayed o) { return Long.compare(this.expirationTime, ((DelayedElement) o).expirationTime); } }
Tämä koodi havainnollistaa DelayedElement-luokan käyttöä, joka toteuttaa Delayed-rajapinnan, sekä DelayQueue-viivejonon käyttöä Javassa. DelayedElement-luokka määrittelee getDelay-metodin jäljellä olevan viiveajan laskemiseen ja compareTo-metodin olioiden vertailuun viiveen päättymisajan perusteella.
main-metodi luo kaksi jonoa: queue1, joka on tyhjä viivejono, ja queue2, joka alustetaan alkioilla, joiden viiveet ovat 5 ja 1 sekuntia.
DelayQueueue-jonon alkiot tulevat saataville haettavaksi vasta määritellyn viiveajan kuluttua.
SynchronousQueueue: Jono ilman kapasiteettia, jossa jokaisen lisäysoperaation on odotettava vastaavaa poisto-operaatiota ja päinvastoin.
Main.java
12345// Constructor without fair access BlockingQueue<String> queue1 = new SynchronousQueue<>(); // Constructor with fair access BlockingQueue<String> queue2 = new SynchronousQueue<>(true);
BlockingQueue:n pääasialliset metodit:
Alkioiden lisääminen:
void put(E e) metodi lisää alkion jonoon, estäen säikeen jos jono on täynnä. Vaihtoehtoisesti boolean offer(E e, long timeout, TimeUnit unit) metodi yrittää lisätä alkion jonoon, odottaen määritetyn ajan jos jono on täynnä.
Main.java
1234567891011121314151617public class BlockingQueueExample { public static void main(String[] args) { BlockingQueue<String> queue = new ArrayBlockingQueue<>(2); try { queue.put("Element 1"); // Insert the first element, no blocking. queue.put("Element 2"); // Insert the second element, no blocking. // Try to add the third element with a 2-second timeout. // Since the queue is full, it will wait for 2 seconds. boolean success = queue.offer("Element 3", 2, TimeUnit.SECONDS); } catch (InterruptedException e) { e.printStackTrace(); } } }
Tämä esimerkki havainnollistaa kahden alkion lisäämistä BlockingQueue-jonoon ilman estoa, minkä jälkeen yritetään lisätä kolmas alkio käyttäen 2 sekunnin aikakatkaisua offer()-metodilla, joka odottaa, jos jono on täynnä.
Alkion noutaminen:
E take() metodi hakee ja palauttaa alkion jonosta, estäen säikeen jos jono on tyhjä. Vaihtoehtoisesti E poll(long timeout, TimeUnit unit) metodi yrittää hakea alkion jonosta, odottaen määritetyn ajan jos jono on tyhjä.
Main.java
1234567891011121314151617181920212223public class BlockingQueueRetrievalExample { public static void main(String[] args) { BlockingQueue<String> queue = new ArrayBlockingQueue<>(2); try { // Adding elements to the queue queue.put("Element 1"); queue.put("Element 2"); // Retrieve and remove the first element, no blocking since the queue is not empty String item1 = queue.take(); // Returns "Element 1" // Attempt to retrieve and remove the next element with a 2-second timeout String item2 = queue.poll(2, TimeUnit.SECONDS); // Returns "Element 2" // Attempt to retrieve an element when the queue is empty, this will block for 2 seconds String item3 = queue.poll(2, TimeUnit.SECONDS); // Returns `null` after timeout } catch (InterruptedException e) { e.printStackTrace(); } } }
Tämä koodi lisää kaksi alkiota BlockingQueue-jonoon, hakee ja poistaa ensimmäisen alkion välittömästi, yrittää hakea seuraavan alkion 2 sekunnin aikakatkaisulla ja lopuksi yrittää hakea alkiota tyhjästä jonosta, mikä johtaa null-arvoon aikakatkaisun jälkeen.
Alkioiden tarkistaminen ja poistaminen:
boolean remove(Object o) metodi poistaa määritetyn alkion jonosta, jos se on läsnä. Vastaavasti boolean contains(Object o) metodi tarkistaa, onko määritetty alkio jonossa ilman, että sitä poistetaan.
Main.java
1234567891011121314151617181920212223242526public class BlockingQueueCheckRemoveExample { public static void main(String[] args) { BlockingQueue<String> queue = new ArrayBlockingQueue<>(2); try { // Adding elements to the queue queue.put("Element 1"); queue.put("Element 2"); // Check if "Element 1" is in the queue, should return `true` boolean containsElement1 = queue.contains("Element 1"); // true // Remove "Element 1" from the queue, should return `true` boolean removedElement1 = queue.remove("Element 1"); // true // Check if "Element 1" is still in the queue, should return `false` boolean containsElement1AfterRemoval = queue.contains("Element 1"); // false // Try to remove an element that is not in the queue, should return `false` boolean removedElement3 = queue.remove("Element 3"); // false } catch (InterruptedException e) { e.printStackTrace(); } } }
Tämä koodi lisää kaksi alkiota BlockingQueue-jonoon, tarkistaa "Element 1" -alkion olemassaolon, poistaa sen, tarkistaa uudelleen varmistaakseen poiston ja yrittää poistaa olemattoman alkion.
Jonon tilan tarkastelu:
int size() metodi palauttaa jonossa olevien alkioiden määrän. Selvittääksesi, onko jono tyhjä, voit käyttää boolean isEmpty() metodia, joka tarkistaa, ettei jonossa ole alkioita. Kiinteän kapasiteetin jonoissa int remainingCapacity() metodi ilmoittaa jonoon jäljellä olevien vapaiden paikkojen määrän.
Main.java
123456789101112131415161718192021222324252627282930public class BlockingQueueCapacityExample { public static void main(String[] args) { BlockingQueue<String> queue = new ArrayBlockingQueue<>(3); try { // Adding elements to the queue queue.put("Element 1"); queue.put("Element 2"); // Get the number of elements in the queue int currentSize = queue.size(); // 2 // Check if the queue is empty boolean isQueueEmpty = queue.isEmpty(); // false // Get the remaining capacity in the queue int remainingSpace = queue.remainingCapacity(); // 1 // Add another element to fill the queue queue.put("Element 3"); // Check the size and remaining capacity after adding the third element currentSize = queue.size(); // 3 remainingSpace = queue.remainingCapacity(); // 0 } catch (InterruptedException e) { e.printStackTrace(); } } }
Tämä koodi lisää alkioita BlockingQueue-jonoon, tarkistaa nykyisen koon, varmistaa onko jono tyhjä, ja määrittää jäljellä olevan kapasiteetin, minkä jälkeen se päivittää nämä arvot täytettyään jonon kokonaan.
Reaaliaikaisen esimerkin toteutus koodissa
😭 Rajoitukset
Yksi keskeinen rajoitus on suorituskyky: lukitusoperaatioiden vuoksi suorituskyky voi heikentyä verrattuna ei-synkronoituun kokoelmaan. Lisäksi resurssit voivat muodostua ongelmaksi, sillä suuret jonot vaativat enemmän muistia ja suoritinaikaa lukkojen ja synkronointiprosessien hallintaan.
💪 Edut
Positiivisena puolena järjestelmä on turvallinen monisäikeisessä ympäristössä, tarjoten turvallisen viestinnän säikeiden välillä ilman manuaalista synkronoinnin hallintaa. Se myös yksinkertaistaa koodia välttämällä monimutkaisia synkronointi- ja estorakenteita. Lisäksi eri BlockingQueue-toteutusten joustavuus mahdollistaa niiden soveltamisen erilaisiin käyttötarkoituksiin.
1. Mikä on BlockingQueue Java-ohjelmoinnissa?
2. Mitkä ovat BlockingQueue:n pääasialliset säiettä estävät metodit?
3. Mihin BlockingQueue on hyödyllinen monisäikeisissä sovelluksissa?
Kiitos palautteestasi!
