Home Java javaTutorial How to use thread pool to implement producer consumer pattern in Java 7

How to use thread pool to implement producer consumer pattern in Java 7

Jul 29, 2023 am 08:37 AM
java Thread Pool producer consumer model

How to use the thread pool to implement the producer-consumer model in Java 7

Introduction: The thread pool is a commonly used thread management mechanism in Java, which can improve the reusability and efficiency of threads. In concurrent programming, the producer-consumer pattern is a common design pattern suitable for collaboration and data exchange between multiple threads. This article will introduce how to use thread pools to implement the producer-consumer pattern in Java 7 and provide code examples.

1. What is the producer-consumer pattern

The producer-consumer pattern is a concurrent design pattern used to solve the data exchange problem between producers and consumers. In the producer-consumer pattern, producers are responsible for generating data, and consumers are responsible for processing data. In order to achieve cooperation and data exchange between threads, it is usually necessary to use a shared buffer. The producer stores data into the buffer, and the consumer takes the data out of the buffer for processing.

2. Advantages of using thread pools to implement the producer-consumer model

Traditionally, we can achieve multi-threaded interaction between producers and consumers by creating Thread objects. However, this method has some problems in practical application. First, when a large number of producers and consumers need to be processed, thread creation and destruction operations will cause a large overhead to system performance. Secondly, there is a certain limit on the number of threads created. Too many threads will lead to resource exhaustion and thread scheduling overhead.

Using a thread pool to implement the producer-consumer model can make full use of the reusability and efficiency of threads. The thread pool can pre-create a certain number of threads when the system starts and put them into the pool. When a new task arrives, the threads in the thread pool can be reused directly, reducing the overhead of thread creation and destruction. At the same time, the thread pool can flexibly control the number of threads and resource allocation, thereby improving the stability and efficiency of the system.

3. Code example of using thread pool to implement producer-consumer pattern

Below we use a simple example to demonstrate how to use thread pool to implement producer-consumer pattern.

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

public class ProducerConsumerExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        Buffer buffer = new Buffer();

        // 生产者线程
        Runnable producer = new Producer(buffer);
        executorService.submit(producer);

        // 消费者线程
        Runnable consumer = new Consumer(buffer);
        executorService.submit(consumer);

        executorService.shutdown();
    }
}

class Buffer {
    private int value;
    private boolean occupied = false;

    public synchronized void produce(int value) {
        while (occupied) {
            try {
                wait();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        this.value = value;
        occupied = true;
        notifyAll();
    }

    public synchronized int consume() {
        while (!occupied) {
            try {
                wait();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        occupied = false;
        notifyAll();
        return value;
    }
}

class Producer implements Runnable {
    private static final int MAX_VALUE = 10;
    private Buffer buffer;

    public Producer(Buffer buffer) {
        this.buffer = buffer;
    }

    @Override
    public void run() {
        for (int i = 0; i < MAX_VALUE; i++) {
            buffer.produce(i);
            System.out.println("Producer produced: " + i);
            try {
                Thread.sleep((int) (Math.random() * 1000));
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}

class Consumer implements Runnable {
    private static final int MAX_VALUE = 10;
    private Buffer buffer;

    public Consumer(Buffer buffer) {
        this.buffer = buffer;
    }

    @Override
    public void run() {
        for (int i = 0; i < MAX_VALUE; i++) {
            int value = buffer.consume();
            System.out.println("Consumer consumed: " + value);
            try {
                Thread.sleep((int) (Math.random() * 1000));
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}
Copy after login

In the above code, we use the thread pool classes ExecutorService and Executors in Java 7 to create a thread pool, and use the fixed-length thread pool newFixedThreadPool to control the number of threads. In the Buffer class, we use the synchronized keyword to implement thread synchronization and mutual exclusion. When there is data in the buffer, the producer needs to wait for the consumer thread to consume the data; when there is no data in the buffer, the consumer needs to wait for the producer thread to produce data.

Through the above code, we can see the typical characteristics of the producer-consumer model: a producer thread is responsible for producing data, a consumer thread is responsible for consuming data, and the producer and consumer use a shared buffer. area for data exchange. The use of thread pools can manage these two threads well, improving the performance and efficiency of the system.

Conclusion: This article introduces how to use thread pools to implement the producer-consumer pattern in Java 7, and provides relevant code examples. By using the thread pool, we can make full use of the reusability and efficiency of threads and improve the stability and performance of the system. I hope this article is helpful for you to learn about concurrent programming and thread pools.

The above is the detailed content of How to use thread pool to implement producer consumer pattern in Java 7. For more information, please follow other related articles on the PHP Chinese website!

Statement of this Website
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn

Hot Article Tags

Notepad++7.3.1

Notepad++7.3.1

Easy-to-use and free code editor

SublimeText3 Chinese version

SublimeText3 Chinese version

Chinese version, very easy to use

Zend Studio 13.0.1

Zend Studio 13.0.1

Powerful PHP integrated development environment

Dreamweaver CS6

Dreamweaver CS6

Visual web development tools

SublimeText3 Mac version

SublimeText3 Mac version

God-level code editing software (SublimeText3)

Square Root in Java Square Root in Java Aug 30, 2024 pm 04:26 PM

Square Root in Java

Perfect Number in Java Perfect Number in Java Aug 30, 2024 pm 04:28 PM

Perfect Number in Java

Random Number Generator in Java Random Number Generator in Java Aug 30, 2024 pm 04:27 PM

Random Number Generator in Java

Armstrong Number in Java Armstrong Number in Java Aug 30, 2024 pm 04:26 PM

Armstrong Number in Java

Weka in Java Weka in Java Aug 30, 2024 pm 04:28 PM

Weka in Java

Smith Number in Java Smith Number in Java Aug 30, 2024 pm 04:28 PM

Smith Number in Java

Java Spring Interview Questions Java Spring Interview Questions Aug 30, 2024 pm 04:29 PM

Java Spring Interview Questions

Break or return from Java 8 stream forEach? Break or return from Java 8 stream forEach? Feb 07, 2025 pm 12:09 PM

Break or return from Java 8 stream forEach?

See all articles