Java生产者消费者模型

╰半橙微兮° 2022-02-21 12:48 300阅读 0赞

生产者和消费者主要的一个点就是对缓冲区的状态做出变化。

当生产者生产的资源满，生产者阻塞，若不满，则继续生产。

当消费者消费资源为空，消费者阻塞，若不空，则继续消费。

当生产者生产的时候，消费者不能消费。

当消费者进行消费的时候，生产者不能生产。

都是对缓冲区的变化做出的相应的措施。

优点：

1.解耦，生产者和消费者2者之间的关系得到释放。各自对缓冲区的变化进行各自的变化。

2.速度上的匹配。比如生产者生产很慢，但是消费者就必须一直阻塞在那吗？占用CPU资源吗？借用计算机的内存和硬盘之间放置高速缓存的概念来提高速度。这就可以想象起到速度匹配的作用。

1.通过wait,notify方法实现线程间的通信。2者根据缓冲区的资源的变化做出相应的变化（阻塞还是操作等等）。

附上代码

package com.hnist.lzn.thread;
    
    public class TestDemoThread {
    
    
        private static Object o = new Object();
    
        //false 代表缓冲区为空  ，true代表满
    
       static boolean  idea = true;
    
        public static void main(String[] args) {
    
        Runnable a = new Runnable() {
            @Override
            public void run() {
                //生产者，为满生产，满停止通知消费者
                while(true) {
                    System.out.println("生产者即将获得锁");
                synchronized (o) {
                    //false
                    System.out.println("生产者获得锁");
                        if (idea) {
    
                            System.out.println("生产者生产满");
    
    
                            try {
                                o.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
    
                        }
                        //生产
                        idea = !idea;
                    System.out.println("生产者生产了"+idea);
                        //产生了就通知消费者消费
                        o.notify();
    
                    }
                    System.out.println("生产者即释放锁");
                    }
    
            }
        };
        Runnable b = new Runnable() {
            @Override
            public void run() {
                while(true) {
                    System.out.println("消费者即得到锁");
                synchronized (o){
                //消费者，有就消费，空就暂停，通知生产者
                    System.out.println("消费者获得锁");
                        if (!idea) {
    
                            System.out.println("消费者消费空了");
    
                            //空就暂停
    
                            try {
                                o.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                        idea = !idea;
                    System.out.println("消费者消费"+idea);
                        //通知生产产生
                        o.notify();
                    }
                    System.out.println("消费者即释放锁");
                }
    
            }
        };
    
        Thread t1 = new Thread(a,"生产者");
    
        Thread t2 = new Thread(b,"消费者");
    
        t1.start();
        t2.start();
    
    
    
    
        }
    
    }

2.当多个生产者线程对缓冲区生产，一个消费者线程进行消费，那么相应的notify就应该变为notifyAll，同时对资源的判断的if条件应该变为while ,为什么要从if变成while？因为单个生产者以及单个消费者线程，每次被唤醒那么肯定是被对方唤醒的（当生产者线程沉睡时，那么是消费进行了消费调用了notify方法把它从沉睡中唤醒，那么资源必然进行了消费，这样生产者就能进行生产，反之亦然）但是在多个生产者线程或者多个消费者线程中，每次唤醒的都是全部的生产者消费者线程，它们都要去竞争锁，如果当前资源刚好处于一种临界条件下，消费者进行消费的同时，会调用notifyAll方法唤醒全部的线程，而每个线程都是从wait()处醒来，那么假设是生产者被唤醒接下来就执行（生产行为），而当时消费者线程还未对资源进行消费，那么就会导致缓冲区已满生产者绕过了限制条件进行生产导致资源数目不对。

附上代码：

package com.hnist.lzn.thread;
    
    public class TestDulityThread {
    
            private static Object o = new Object();
    
            //false 代表缓冲区为空  ，true代表满
    
            //static boolean  idea = true;
    
            //0为空 50 为满
            private  static int index = 0;
    
            private static int max = 50;
    
            public static void main(String[] args) {
    
                Runnable a = new Runnable() {
                    @Override
                    public void run() {
                        //生产者，为满生产，满停止通知消费者
                        while(true) {
                            System.out.println(Thread.currentThread().getName()+"即将获得锁");
                            synchronized (o) {
                                //false
                                System.out.println(Thread.currentThread().getName()+"获得锁");
                                while (index==max) {
    
                                    System.out.println(Thread.currentThread().getName()+"生产满");
    
    
                                    try {
                                        o.wait();
                                    } catch (InterruptedException e) {
                                        e.printStackTrace();
                                    }
    
                                }
                                //生产
                                index++;
                                System.out.println(Thread.currentThread().getName()+"生产了"+index);
                                //产生了就通知消费者消费
                                o.notifyAll();
    
                            }
                            System.out.println(Thread.currentThread().getName()+"即释放锁");
                        }
    
                    }
                };
                Runnable b = new Runnable() {
                    @Override
                    public void run() {
                        while(true) {
                            System.out.println(Thread.currentThread().getName()+"即得到锁");
                            synchronized (o){
                                //消费者，有就消费，空就暂停，通知生产者
                                System.out.println(Thread.currentThread().getName()+"获得锁");
                                while (index==0) {
    
                                    System.out.println(Thread.currentThread().getName()+"消费空了");
    
                                    //空就暂停
    
                                    try {
                                        o.wait();
                                    } catch (InterruptedException e) {
                                        e.printStackTrace();
                                    }
                                }
                                index--;
                                System.out.println(Thread.currentThread().getName()+"消费"+index);
                                //通知生产产生
                                o.notifyAll();
                            }
                            System.out.println(Thread.currentThread().getName()+"即释放锁");
                        }
    
                    }
                };
    
                Thread t1 = new Thread(a,"生产者1");
                Thread t3 = new Thread(a,"生产者2");
    
                Thread t2 = new Thread(b,"消费者");
    
                t1.start();
                t3.start();
                t2.start();
    
    
    
    
            }
    
        }