How to implement producer and consumer models in Java function concurrency and multi-threading?

In Java, concurrency and multithreading allow multiple tasks to be executed simultaneously. The producer and consumer model is a classic concurrency model that uses queues to coordinate producer threads and consumer threads, which can achieve simultaneous production and consumption of elements.

Concurrency and multithreading of Java functions: Implementing the producer and consumer model

Concurrency and multithreading are important concepts in Java that allow applications Programs perform multiple tasks simultaneously. The producer and consumer model is a classic pattern in concurrent programming, which uses queues to coordinate producer threads and consumer threads.

Use Java functions to implement producer and consumer models

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.function.Supplier;

public class ProducerConsumer {

  private static BlockingQueue<Integer> queue = new LinkedBlockingQueue<>();

  public static void main(String[] args) {
    Supplier<Integer> producer = () -> {
      while (true) {
        try {
          // 生产一个元素
          int element = produce();

          // 将元素放入队列
          queue.put(element);

          // 稍作休息，模拟生产时间
          Thread.sleep(100);
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
    };

    Consumer<Integer> consumer = (element) -> {
      while (true) {
        try {
          // 从队列中取出元素
          element = queue.take();

          // 消费元素
          consume(element);

          // 稍作休息，模拟消费时间
          Thread.sleep(100);
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
    };

    // 创建一个生产者线程
    Thread producerThread = new Thread(producer);

    // 创建两个消费者线程
    Thread consumerThread1 = new Thread(consumer);
    Thread consumerThread2 = new Thread(consumer);

    // 启动线程
    producerThread.start();
    consumerThread1.start();
    consumerThread2.start();
  }

  // 模拟生产元素的方法
  private static int produce() {
    return (int) (Math.random() * 100);
  }

  // 模拟消费元素的方法
  private static void consume(int element) {
    System.out.println("Consumed element: " + element);
  }
}

Practical case

This code simulates a producer and a two-consumer model, where the producer randomly generates numeric elements and puts them into a queue, while the consumer takes elements off the queue and prints them. In this way, applications are able to handle both production and consumption elements.

Usage Example

You can run this code in the command line:

$ javac ProducerConsumer.java
$ java ProducerConsumer

You will see the consumer thread output text similar to the following:

Consumed element: 23
Consumed element: 72
Consumed element: 15
Consumed element: 44
Consumed element: 87
...

This indicates that the producer and consumer models are running successfully and the consumer thread is dequeuing and printing the elements produced by the producer thread.

The above is the detailed content of How to implement producer and consumer models in Java function concurrency and multi-threading?. For more information, please follow other related articles on the PHP Chinese website!