首页 > 编程语言> 文章详细

Java实现多线程中生产者、消费者问题，简单易懂

2022-02-01 20:02:45 阅读：182 来源： 互联网

标签：Java 消费者生产者 clerk 产品易懂多线程 Clerk 店员

思想：

1、生产者在while循环里不停地生产“产品”，每生产一个，就交给店员，店员就得到一个产品

2、消费者在while循环里不停地消费产品，每消费一个，店员就移走一个产品

3、店员手里的产品少于20个，就从生产者那里拿走产品。等于20个，就停止从生产者那里拿走产品

4、店员手里的产品多于0个，就让消费者消费产品。等于0个，就停止让消费者消费产品

生产者：

生产者在while循环里不停地生产“产品”，每生产一个，就交给店员，店员就得到一个产品

//生产者
class Producter implements Runnable{
    Clerk clerk;
    Producter(Clerk clerk){
        this.clerk=clerk;
    }
    @Override
    public void run() {
        while (true){
            //此处可加sleep，让生产者生产的慢一点
            clerk.getProduce();//生产者不停地生产产品，生产一个，就交给店员，店员就get一个
        }
    }
}

消费者：

消费者在while循环里不停地消费产品，每消费一个，店员就移走一个产品

//消费者
class Consummer implements Runnable{
    Clerk clerk;
    Consummer(Clerk clerk){
        this.clerk=clerk;
    }
    @Override
    public void run() {
        while (true){
           //此处可加sleep，让消费者消费的慢一些
            clerk.removeProduce();//消费者不停地消费产品，消费一个，店员处就remove一个
        }
    }
}

店员：

店员手里的产品少于20个，就从生产者那里拿走产品。等于20个，就停止从生产者那里拿走产品

店员手里的产品多于0个，就让消费者消费产品。等于0个，就停止让消费者消费产品

//店员
class Clerk{

    public int producenumber;//店员手里产品的数量

    public synchronized void getProduce() {//锁是clerk，反复执行的实际上是该方法和removeProduce方法
        if(producenumber<20){//店员手里产品数量少于20个，就从生产者那里拿过来一个
            producenumber++;
            System.out.println(Thread.currentThread().getName()+"生产了第"+producenumber+"个产品");
            notify();//已经从生产者那里拿过来一个产品了，说明手里肯定是有产品的，店员可以让消费者拿走产品了
        }else{
            try {
                wait();//店员手里产品数量多于20个，停止从生产者那里拿走产品
            } catch (InterruptedException e) {
                System.out.println(e.getMessage());
            }
        }
    }
    public synchronized void removeProduce(){//锁是clerk，相当于四个线程一个一个的执行
        if(producenumber>0){//店员手里产品数量多余0个，就让消费者拿走产品
            System.out.println(Thread.currentThread().getName()+"消费了第"+producenumber+"个产品");
            producenumber--;
            notify();//已经让消费者拿走了一个产品，说明柜台肯定有位置放产品，店员可以从生产者那里取产品了
        }else{
            try {
                wait();//店员手里产品数量少于0个，停止让消费者拿走产品
            } catch (InterruptedException e) {
                System.out.println(e.getMessage());
            }
        }
    }
}

测试类：

public class ThreadCommunicationTest {
    public static void main(String[] args) {
        Clerk clerk=new Clerk();

        Producter p=new Producter(clerk);
        Thread tp1=new Thread(p);
        tp1.setName("生产者1");
        tp1.start();
        Thread tp2=new Thread(p);
        tp2.setName("生产者2");
        tp2.start();

        Consummer c=new Consummer(clerk);
        Thread tc1=new Thread(c);
        tc1.setName("消费者1");
        tc1.start();
        Thread tc2=new Thread(c);
        tc2.setName("消费者2");
        tc2.start();
    }
}

Attention：

一共有四个线程：生产者1、生产者2、消费者1、消费者2

生产者1和生产者2线程开启后，调用Producter类里的run方法，又在run方法里调用Clerk类里的getProduce方法

相当于生产者1和生产者2反复执行的是getProduce方法

生产者1和生产者2线程开启后，调用PConsummer类里的run方法，又在run方法里调用Clerk类里的removeProduce方法

相当于消费者1和消费者2反复执行的是removeProduce方法

而getProduce方法和removeProduce方法都是同步方法，它们都在Clerk类中定义，而Clerk类从始至终只有一个对象，所以两个同步方法的锁是同一把，即Clerk类的实例对象clerk

意味着在两个方法中，四个线程只能一个一个的执行，因此线程安全

执行截图：

标签：Java,消费者,生产者,clerk,产品,易懂,多线程,Clerk,店员
来源： https://blog.csdn.net/qq_52803229/article/details/122765438

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9