Comment implémenter le modèle producteur-consommateur en utilisant la file d'attente de blocage en Java ?

La file d'attente de blocage en Java est utilisée pour implémenter le modèle producteur-consommateur : les threads producteurs ajoutent des données à la file d'attente et les threads consommateurs lisent les données de la file d'attente. Lorsque la file d'attente est pleine, le producteur bloque jusqu'à ce que de l'espace soit disponible ; lorsque la file d'attente est vide, le consommateur bloque jusqu'à ce qu'il y ait des données à lire. Cas pratiques : problèmes de concurrence tels que les systèmes de mise en cache, les files d'attente de messages et le traitement des pipelines.

Utilisez la file d'attente de blocage pour implémenter le modèle producteur-consommateur en Java

La file d'attente de blocage est une structure de données thread-safe qui peut nous aider à réaliser la synchronisation entre les producteurs et les consommateurs. Les threads producteurs ajoutent des données à la file d'attente, tandis que les threads consommateurs lisent les données de la file d'attente. Si la file d'attente est pleine, le producteur bloque jusqu'à ce que de l'espace soit disponible. Si la file d'attente est vide, le consommateur bloque jusqu'à ce que les données soient disponibles en lecture.

Exemple de code :

Producer.java

import java.util.concurrent.BlockingQueue;

public class Producer implements Runnable {

    private BlockingQueue<Integer> queue;

    public Producer(BlockingQueue<Integer> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                queue.put(i);
                System.out.println("Produced: " + i);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Consumer.java

import java.util.concurrent.BlockingQueue;

public class Consumer implements Runnable {

    private BlockingQueue<Integer> queue;

    public Consumer(BlockingQueue<Integer> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        while (true) {
            try {
                Integer item = queue.take();
                System.out.println("Consumed: " + item);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Main.java

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {

    public static void main(String[] args) {
        BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);

        Producer producer = new Producer(queue);
        Consumer consumer = new Consumer(queue);

        ExecutorService executorService = Executors.newFixedThreadPool(2);
        executorService.submit(producer);
        executorService.submit(consumer);

        executorService.shutdown();
    }
}

Cas pratique :

Ce modèle peut être utilisé pour résoudre une variété de concurrence problèmes, Par exemple :

• Dans un système de cache, les threads producteurs génèrent des données et les threads consommateurs consomment les données.
• Dans un système de file d'attente de messages, les threads producteurs publient des messages et les threads consommateurs traitent les messages.
• Dans le traitement du pipeline, le thread producteur génère des données intermédiaires, tandis que le thread consommateur traite les données intermédiaires et génère le résultat final.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!