notify 和 wait 实现生产者消费者模型

拼搏现实的明天。 2022-10-12 05:57 194阅读 0赞

1.  **对于wait()和notify()的理解**  
    void notify()  
    唤醒在此对象监视器上等待的单个线程  
    void notifyAll()  
    唤醒在此对象监视器上等待的所有线程  
    void wait( )  
    导致当前的线程等待，直到其他线程调用此对象的notify( ) 方法或 notifyAll( ) 方法  
    void wait(long timeout)  
    是指在一个已经进入了同步锁的线程内，让自己暂时让出同步锁，以便其他正在等待此锁的线程可以得到同步锁并运行（释放锁，阻塞当前线程）  
    void wait(long timeout, int nanos)  
    导致当前的线程等待，直到其他线程调用此对象的notify( ) 方法或 notifyAll( ) 方法，或者其他线程打断了当前线程，或者指定的时间过完。  
    以上方法调用，主要是对加锁资源的竞争，synchronized 否则会报IllegalMonitorStateException 异常
2.  生产者消费者

public class Threads1 {
        public static void main(String[] args) {
            Threads1 consumer = new Threads1();
            consumer.print();
        }
    
        class Res{
            String userName;
            String sex;
            // false  ----InputThread 赋值  唤醒 OuputThread
            //true -- OuputThread赋值  唤醒 InputThread
            public boolean flag = false;
        }
    
        class InputThread extends Thread{
            private Res res;
    
            public InputThread(Res res){
                this.res = res;
            }
    
            @Override
            public void run() {
                while (true){
                    synchronized (res){
                        //false  则进行当前线程   否则进行阻塞
                        if (res.flag) {
                            try {
                                //释放当前锁，同时进行阻塞
                                res.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                        res.userName = "王孝峰的女朋友";
                        res.sex = "女";
                        System.out.println(res.toString());
                        res.flag = true;
                        res.notify();
                    }
                }
            }
        }
    
        class OuputThread extends Thread{
            private Res res;
    
            public OuputThread(Res res){
                this.res = res;
            }
            @Override
            public void run() {
                while (true){
                    synchronized (res){
                        if(!res.flag){
                            try {
                                //释放当前锁，同时进行阻塞
                                res.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                        res.userName = "王孝峰";
                        res.sex = "男";
                        System.out.println(res.toString());
                        res.flag = true;
                        res.notify();
                    }
                }
            }
        }
    
        public void print() {
            // 全局对象
            Res res = new Res();
            // 输入线程
            InputThread inputThread = new InputThread(res);
            OuputThread ouputThread = new OuputThread(res);
            inputThread.start();
            ouputThread.start();
        }
    
    }

主要思想就是  
输入线程输入参数之后唤醒输出线程，同时自己进行wait  
输出线程输入参数之后唤醒输入线程，同时自己进行wait