java notify() wait() synchronized 生产者与消费者案例

懒得写了,直接看代码把

手机类

/**
 * 手机类
 * 最多生产多少手机
 * @author HWUA
 *
 */
public class Shouji{
    public int max; //定义容器最大容量
    public int currentNum;//定义容器当前容量
     
    public Shouji(int max){
        this.max = max;
        currentNum = 0;
    }
}

生产类

//生产手机类
public class Sjphone1 implements Runnable{
    public Shouji con;
    public Sjphone1(Shouji con){//构造函数
        this.con = con;
    }
    public void run(){
        while(true){//一直运行
            synchronized(con){//手机类锁
                if(con.currentNum < con.max){//若当前容器不满，则可以生产
                    con.notify();//生产完则通知并释放锁
                    con.currentNum++;
                    System.out.println(" 生产者正在生产小米手机1部, 当前产品数："+con.currentNum+"部");
                }else if(con.currentNum == con.max){//若生产手机等于最大定义手机市场容量
                    System.out.println("手机生产已经饱和，生产者停止生产，正在等待消费..."); 
                    try {
                        con.wait();//暂停生产 并释放锁
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }//if else if               
            }//syn  执行完同步块  释放锁，输出结果中连续出现两次生产者是因为：释放锁后，若没有等待线程，则还是先执行到哪个线程的同步块就执行它
             
            try {
                Thread.sleep(100);//调节生产者频率，过快容易猝死~~
            } catch (InterruptedException e) {
                e.printStackTrace();
            }//try
        }//while
    }
}

消费类

//消费类
public class Sjphone2 implements Runnable{
    public Shouji con;
    public Sjphone2(Shouji con){//构造函数
        this.con = con;
    }
    public void run(){
        while(true){//一直运行
            synchronized(con){//手机锁
                if(con.currentNum > 0 ){//当有手机的时候
                    con.notify();//购买手机 并释放锁
                    con.currentNum--;
                    System.out.println(" 消费者正在消费小米手机卖出1部, 当前产品数："+con.currentNum+"部");
                }else if(con.currentNum == 0){//若没有手机了
                    System.out.println("手机已经买完了，消费者停止消费，正在等待生产..."); 
                    try {
                        con.wait();//暂停消费 并释放锁
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }//else if              
            }//syn      
             
            try {
                Thread.sleep(140);//调节消费者频率，过快容易撑死~~
            } catch (InterruptedException e) {
                e.printStackTrace();
            }//try
        }//while
    }// run
}

测试类main

/**
 * 测试类
 */
public class Dome01{
    public static void main(String args[]){
        Shouji container = new Shouji(5);//定义最大定义手机市场容量，此处为5
        Sjphone1 sj1 =  new Sjphone1(container);//箱子中的手机数要同步，所以将手机对象引用作为形参传给生产者和消费者
        Sjphone2 sj2 = new Sjphone2(container);//同上
        //启动生产消费模式
        new Thread(sj1, "生产").start();
        new Thread(sj2, "消费").start();
        
    }
}

注意记得锁的对象一定要是

构造函数  对应

Shouji 类

同一个对象,不然线程会乱跑,没有规律,一定要锁起来