java多线程初探（零）生产者消费者模式-线程通信

最新推荐文章于 2022-08-19 15:57:30 发布

gcc_front

最新推荐文章于 2022-08-19 15:57:30 发布

阅读量163

点赞数

CC 4.0 BY-SA版权

分类专栏：多线程

本文链接：https://blog.youkuaiyun.com/gcc_java/article/details/81390853

多线程专栏收录该内容

8 篇文章

订阅专栏

本文介绍了一个基于Java实现的多线程生产者消费者模型。该模型通过多个生产者和消费者线程共享同一把锁来确保数据一致性，并使用wait和notifyAll方法协调线程间的活动。每个生产者和消费者线程都在循环中执行生产或消费操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

测试类

package gcc.twoThreadTransData.producerAndConsumer;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 多个线程之间通信
 * 消费者生产者模式
 * 多个生产者和消费者
 * 流程：
 * 多个线程（生产者，消费者）公用一把锁
 * 本例设置了两个生产者线程和两个消费者线程
 * 启动线程，run方法内循环调用生产和消费方法
 * 无数据，生产，notifyAll唤醒所有wait等待（不管是消费者的还是生产者的）
 * 有数据，不生产，wait等待
 * 有数据，消费，数据置空，notifyAll唤醒所有wait等待
 * 无数据，不消费，wait等待
 */
public class TestPCModel {

    protected static Logger logger = LoggerFactory.getLogger(TestPCModel.class);

    public static void main(String[] args) throws InterruptedException {
        String lock =  new String("");
        Producer p = new Producer(lock);
        Consumer c = new Consumer(lock);
        ThreadP[] pThread = new ThreadP[2];
        ThreadC[] cThread = new ThreadC[2];
        for (int i = 0; i <2 ; i++) {
            pThread[i]=new ThreadP(p);
            pThread[i].setName("生产者-"+i);
            cThread[i]=new ThreadC(c);
            cThread[i].setName("消费者-"+i);
            pThread[i].start();
            cThread[i].start();
        }
        /*Thread.sleep(2000);
        Thread[] threadArray = new Thread[Thread.currentThread().getThreadGroup().activeCount()];
        Thread.currentThread().getThreadGroup().enumerate(threadArray);
        for (int i = 0; i <threadArray.length ; i++) {
            logger.info(threadArray[i].getName()+"---"+threadArray[i].getState());
        }*/

    }

}

生产者类

package gcc.twoThreadTransData.producerAndConsumer;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Producer {

    protected static Logger logger = LoggerFactory.getLogger(Producer.class);

    private String lock;
    public Producer(String lock){
        this.lock=lock;
    }

    public void setValue(){
        try {
            synchronized (lock) {
                while (!"".equals(ValueObject.value)){
                    logger.info("已生产，等待消费："+Thread.currentThread().getName());
                    lock.wait();
                }
                logger.info("开始生产："+Thread.currentThread().getName());
                String value=System.currentTimeMillis()+"--"+System.nanoTime();
                ValueObject.value=value;
                lock.notifyAll();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

消费者类

package gcc.twoThreadTransData.producerAndConsumer;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Consumer {

    protected static Logger logger = LoggerFactory.getLogger(Consumer.class);

    private String lock;
    public Consumer(String lock){
        this.lock=lock;
    }

    public void getValue(){
        try {
            synchronized (lock) {
                while (ValueObject.value.equals("")){
                    logger.info("已消费完："+Thread.currentThread().getName());
                    lock.wait();
                }
                logger.info("开始消费："+Thread.currentThread().getName());
                ValueObject.value="";
                lock.notifyAll();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

生产者线程

package gcc.twoThreadTransData.producerAndConsumer;

public class ThreadP extends Thread{

    private Producer producer;
    public ThreadP(Producer producer){
        this.producer=producer;
    }

    public void run(){
        while (true){
            producer.setValue();
        }
    }

}

消费者线程

package gcc.twoThreadTransData.producerAndConsumer;

public class ThreadC extends Thread{

    private Consumer consumer;
    public ThreadC(Consumer consumer){
        this.consumer=consumer;
    }

    public void run(){
        while (true){
            consumer.getValue();
        }
    }

}

辅助类

package gcc.twoThreadTransData.producerAndConsumer;

public class ValueObject {

    public static String value="";

}