Cloud-Lösungen der Zukunft - Testen!

Revolutionäre Cloud-Technologie, ganz ohne versteckte Kosten. Profitieren Sie von unserer Testphase und entdecken Sie umfassende Funktionen. Der Anmeldeprozess ist transparent und unkompliziert. Starten Sie jetzt Ihre Reise in die Cloud - Kostenfrei!

Java BlockingQueue

Java BlockingQueue akzeptiert keine Nullwerte und wirft eine NullPointerException, wenn Sie versuchen, einen Nullwert in die Warteschlange zu speichern. Java BlockingQueue-Implementierungen sind threadsicher. Alle Warteschlangenmethoden sind von Natur aus atomar und verwenden interne Sperren oder andere Formen der Nebenläufigkeitssteuerung. Das Java BlockingQueue-Interface ist Teil des Java Collections Frameworks und wird hauptsächlich zur Implementierung des Produzenten-Konsumenten-Problems verwendet. Wir müssen uns keine Sorgen machen, auf verfügbaren Platz für den Produzenten oder verfügbare Objekte für den Konsumenten in der BlockingQueue zu warten, da dies von den Implementierungsklassen der BlockingQueue gehandhabt wird. Java bietet mehrere BlockingQueue-Implementierungen wie ArrayBlockingQueue, LinkedBlockingQueue, PriorityBlockingQueue, SynchronousQueue usw. Bei der Implementierung des Produzenten-Konsumenten-Problems in der BlockingQueue werden wir die ArrayBlockingQueue-Implementierung verwenden. Folgend sind einige wichtige Methoden, die Sie kennen sollten.

Wichtige Methoden

  • put(E e): Diese Methode wird verwendet, um Elemente in die Warteschlange einzufügen. Wenn die Warteschlange voll ist, wartet sie, bis Platz verfügbar ist.
  • E take(): Diese Methode holt und entfernt das Element vom Kopf der Warteschlange. Wenn die Warteschlange leer ist, wartet sie, bis ein Element verfügbar ist.

Java BlockingQueue Beispiele

Message

        package com.journaldev.concurrency;

        public class Message {
            private String msg;
            
            public Message(String str){
                this.msg=str;
            }

            public String getMsg() {
                return msg;
            }
        }

Producer

        package com.journaldev.concurrency;

        import java.util.concurrent.BlockingQueue;

        public class Producer implements Runnable {

            private BlockingQueue<Message> queue;
            
            public Producer(BlockingQueue<Message> q){
                this.queue=q;
            }
            @Override
            public void run() {
                //produce messages
                for(int i=0; i<100; i++){
                    Message msg = new Message(""+i);
                    try {
                        Thread.sleep(i);
                        queue.put(msg);
                        System.out.println("Produced "+msg.getMsg());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //adding exit message
                Message msg = new Message("exit");
                try {
                    queue.put(msg);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

Consumer

        package com.journaldev.concurrency;

        import java.util.concurrent.BlockingQueue;

        public class Consumer implements Runnable{

        private BlockingQueue<Message> queue;
            
            public Consumer(BlockingQueue<Message> q){
                this.queue=q;
            }

            @Override
            public void run() {
                try{
                    Message msg;
                    //consuming messages until exit message is received
                    while((msg = queue.take()).getMsg() !="exit"){
                    Thread.sleep(10);
                    System.out.println("Consumed "+msg.getMsg());
                    }
                }catch(InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

Service

        package com.journaldev.concurrency;

        import java.util.concurrent.ArrayBlockingQueue;
        import java.util.concurrent.BlockingQueue;

        public class ProducerConsumerService {

            public static void main(String[] args) {
                //Creating BlockingQueue of size 10
                BlockingQueue<Message> queue = new ArrayBlockingQueue<>(10);
                Producer producer = new Producer(queue);
                Consumer consumer = new Consumer(queue);
                //starting producer to produce messages in queue
                new Thread(producer).start();
                //starting consumer to consume messages from queue
                new Thread(consumer).start();
                System.out.println("Producer and Consumer has been started");
            }
        }

Ausgabe

Die Ausgabe des oben genannten Java BlockingQueue-Beispielprogramms wird unten angezeigt.

Producer and Consumer has been started
Produced 0
Produced 1
Produced 2
Produced 3
Produced 4
Consumed 0
Produced 5
Consumed 1
Produced 6
Produced 7
Consumed 2
Produced 8
...

Java Thread sleep wird bei Produzenten und Konsumenten verwendet, um Nachrichten mit einiger Verzögerung zu produzieren und zu konsumieren.

Start Your Cloud Journey Today with Our Free Trial!

Dive into the world of cloud computing with our exclusive free trial offer. Experience the power, flexibility, and scalability of our cloud solutions firsthand.

Try for free!