Java学习之线程通信（多线程（synchronized））--生产者消费者

分析线程经典案例生产者消费者

/**
共享数据
*/
class Resource
{
    private String name;
    private int count=1;
    private boolean flag=false;
    
    public synchronized void set(String name)
    {    
        if(flag)
            try{this.wait();}catch(InterruptedException e){}
        this.name=name+count;
        count++;
        System.out.println(Thread.currentThread().getName() + "...生产者..." + this.name);
        flag = true;
        notify();
    }
    
    public synchronized void out() 
    {
        if(!flag)
            try{this.wait();}catch(InterruptedException e){}
        System.out.println(Thread.currentThread().getName() + "==消费者==" + this.name);
        flag = false;
        notify();
    }
}

//定义线程任务（生产者线程）
class Producer implements Runnable
{
    private Resource r;
    
    Producer(Resource r)
    {
        this.r=r;
    }
    public void run()
    {
        while(true)
        {
            r.set("商品");
        }
    }
}
//定义线程任务（消费者线程）
class Consumer implements Runnable
{
    private Resource r;
    
    Consumer(Resource r)
    {
        this.r=r;
    }
    
    public void run()
    {
        while(true)
        {
            r.out();
        }
    }
}

class ProducerConsumerDemo
{
    public static void main(String[] args)
    {
        //实例化共享资源
        Resource r = new Resource();
        //实例化线程任务，指定共享资源
        Producer p=new Producer(r);
        Consumer c=new Consumer(r);
        //实例化线程，指定线程任务
        Thread t0=new Thread(p);
        Thread t1=new Thread(p);
        Thread t2=new Thread(c);
        Thread t3=new Thread(c);
        //开启线程，执行线程任务中的run方法
        t0.start();
        t1.start();
        t2.start();
        t3.start();
    }
}

运行结果：

结果分析：

那么怎么再判断flag呢？while

代码如下：

class Resource
{
    private String name;
    private int count=1;
    private boolean flag=false;
    
    public synchronized void set(String name) // 有两个线程t0 t1
    {    
        while(flag)
            try{this.wait();}catch(InterruptedException e){}
        this.name=name+count;
        count++;
        System.out.println(Thread.currentThread().getName() + "...生产者..." + this.name);
        flag = true;
        notify();
    }
    
    public synchronized void out() // 有两个线程t2 t3
    {
        while(!flag)
            try{this.wait();}catch(InterruptedException e){}
        System.out.println(Thread.currentThread().getName() + "==消费者==" + this.name);
        flag = false;
        notify();
    }
}

结果出现死锁：

结果分析：

通过分析，那能不能每次唤醒只唤醒对方线程（如生产者线程只唤醒消费者线程，消费者线程只唤醒生产者线程），查看Object对象方法中没有，但是有一个notifyAll()方法，实在不行就把所有阻塞线程（相同同步锁的线程）都唤醒。

class Resource
{
    private String name;
    private int count=1;
    private boolean flag=false;
    
    public synchronized void set(String name) // 有两个线程t0 t1
    {    
        while(flag)
            try{this.wait();}catch(InterruptedException e){}
        this.name=name+count;
        count++;
        System.out.println(Thread.currentThread().getName() + "...生产者..." + this.name);
        flag = true;
        notifyAll();
    }
    
    public synchronized void out() // 有两个线程t2 t3
    {
        while(!flag)
            try{this.wait();}catch(InterruptedException e){}
        System.out.println(Thread.currentThread().getName() + "==消费者==" + this.name);
        flag = false;
        notifyAll();
    }
}

结果：

这样就可以了。

总结：

if判断只能判断一次，如果执行等待方法，下次唤醒的线程获取执行权后（唤醒后的线程会从上次等待位置，向下执行）就不能再判断

while判断解决唤醒的线程获取执行权后无法判断

notify：只能唤醒任意一个线程，有可能会唤醒本方线程，while+notify会导致死锁

notifyAll:解决了死锁问题