多线程经典——生产者消费者问题（加锁版）

本文链接：https://blog.csdn.net/qq_31634461/article/details/78305410

本文介绍了一个使用Java实现的生产者消费者模式案例。通过Lock接口和Condition接口管理线程间的同步与唤醒，实现了资源的生产和消费过程。代码展示了如何利用ReentrantLock来控制对共享资源的访问，并通过两个不同的Condition对象分别协调生产者和消费者的等待与通知。

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

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/*
 * 生产者，消费者
 * Lock接口：出现替代了同步代码块或者同步函数，将同步的隐式锁操作变成现实锁操作，
 *        同时更加灵活，可以一个锁上加多组监视器。
 *        lock()获取锁
 *        unlock()释放锁，通常定义在finally代码块中
 * Condition接口：出现替代了Object中的wait notify notifyAll方法
 *        将这些监视器方法单独进行了封装，变成Condition监视器对象。可以任意锁进行组合
 *      await() signal() signalAll()
 * 
 * */

class Resrouce
{
    private String name;
    private int count=1;
    private boolean flag=false;
    //创建一个锁对象
    Lock lock=new ReentrantLock();
    //通过已有的锁获取该锁上的监视器对象
//  Condition con=lock.newCondition();
    //通过已有的梭获取两组监视器，一组监视生产者，一组监视消费者
    Condition producer_con=lock.newCondition();
    Condition consumer_con=lock.newCondition();
    public void set(String name)

    {
        lock.lock();
        try
        {
            while(flag)
        try{producer_con.await();}
        catch(InterruptedException e)
        {}
        this.name=name+count;
        count++;
        System.out.println(Thread.currentThread().getName()+"..生产者."+this.name);
        flag=true;
        consumer_con.signal();
        }
        finally
        {
            lock.unlock();
        }

    }
    public  void out()
    {    
        lock.lock();
        try
        {
            while(!flag)
        try{consumer_con.await();}
        catch(InterruptedException e)
        {}
        System.out.println(Thread.currentThread().getName()+"..消费者............."+this.name);
        flag=false;
        producer_con.signal();
        }
        finally
        {
            lock.unlock();
        }

    }
}
class Producer implements Runnable
{
    private Resrouce r;
    Producer(Resrouce r)
    {
        this.r=r;
    }
    public void run()
    {
        while(true)
        {
            r.set("烤鸭");
        }
    }
}
class Consumer implements Runnable
{
    private Resrouce r;
    Consumer(Resrouce r)
    {
        this.r=r;
    }
    public void run()
    {
        while(true)
        {
            r.out();
        }
    }
}

public class Demo  
{

    public static void main(String[] args) 
    {       
        Resrouce r=new Resrouce();
        Producer pro=new Producer(r);
        Consumer con=new Consumer(r);
        Thread t1=new Thread(pro);
        Thread t2=new Thread(con);
        Thread t3=new Thread(pro);
        Thread t4=new Thread(con);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }

}