编程语言
首页 > 编程语言> > Java实现多线程中生产者、消费者问题,简单易懂

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

作者:互联网

思想:

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