生产者与消费者（综合案例）

基础模型：

　　生产者和消费者是一道最为经典的供求案例，而想这供求案例：provider、consumer 在以后进行各种分布式结构开发之后都会被大量采用

　　现在假设说目的：生产者负责生产一个完整的数据之后，消费者就要把这些数据取走。于是现在假设生产如下的数据：

　　　　title=老李 note=是个好人

　　　　title=名族败类 note=老方B

范例：编写程序的基础模型

package cn.Tony.demo;
public  class TestDemo {
    public static void main(String[] args) throws Exception {
        Data data=new Data();
        new Thread(new DataProvider(data)).start();
        new Thread(new DataConsumer(data)).start();
    }
}
class DataProvider implements Runnable{
    private Data data;
    public DataProvider(Data data) {
        this.data=data;
    }
    @Override
    public void run() {
        for(int x=0;x<50;x++) {
            if(x%2==0) {
                this.data.setTitle("老李");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                this.data.setNote("是个好人");
            }else {
                this.data.setTitle("民族败类");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                this.data.setNote("老方b");
            }
        }
    }
}
class DataConsumer implements Runnable{
    private Data data;
    public DataConsumer(Data data) {
        this.data=data;
    }
    @Override
    public void run() {
        for(int x=0;x<50;x++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(this.data.getTitle()+"="+this.data.getNote());
        }
    } 
}
class Data{//负责数据保存
    private String title;
    private String note;
    public void setNote(String note) {
        this.note=note;
    }
    public String getNote() {
        return this.note;
    }
    public void setTitle(String title) {
        this.title=title;
    }
    public String getTitle() {
        return this.title;
    }
}
 

　　这个时候就已经可以发现程序出现两类问题：

　　　　数据不完整，明明是好人，结果成败类

　　　　数据的重复操作问题（重复设置，或重复取出）

解决重复问题

　　如果要想解决同步问题，那么可以立刻想到使用synchronized关键字来定义同步的操作方法，所以代码修改如下：

package cn.Tony.demo;
public  class TestDemo {
    public static void main(String[] args) throws Exception {
        Data data=new Data();
        new Thread(new DataProvider(data)).start();
        new Thread(new DataConsumer(data)).start();
    }
}
class DataProvider implements Runnable{
    private Data data;
    public DataProvider(Data data) {
        this.data=data;
    }
    @Override
    public void run() {
        for(int x=0;x<50;x++) {
            if(x%2==0) {
                this.data.set("老李","老李是个好人");
                
            }else {
                this.data.set("民族败类","老放b");
            }
        }
    }
}
class DataConsumer implements Runnable{
    private Data data;
    public DataConsumer(Data data) {
        this.data=data;
    }
    @Override
    public void run() {
        for(int x=0;x<50;x++) {
            this.data.get();
        }
    } 
}
class Data{//负责数据保存
    private String title;
    private String note;
    public synchronized void get() {
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println(this.title+"="+this.note);
    }
    public synchronized void set(String title,String note) {
        this.title=title;
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        this.note=note;
    }
}
 

　　于是现在发现，整个的程序里面数据的同步问题得到了很好的，但是重复操作的问题更加严重了，

解决数据的重复操作问题：

　　如果想要解决重复问题，就要添加唤醒和等待机制，如果想使用这一个功能，那么就要参考Object类中的方法。

　　等待 死等：public final void wait()throws InterruptedException

　　唤醒第一个等待线程：public final void notify()

　　唤醒全部等待线程，那 个优先级高，谁有可能先执行:public final void notifyAll()

范例：通过等待和唤醒机制解决重复操作问题

package cn.Tony.demo;
public  class TestDemo {
    public static void main(String[] args) throws Exception {
        Data data=new Data();
        new Thread(new DataProvider(data)).start();
        new Thread(new DataConsumer(data)).start();
    }
}
class DataProvider implements Runnable{
    private Data data;
    public DataProvider(Data data) {
        this.data=data;
    }
    @Override
    public void run() {
        for(int x=0;x<50;x++) {
            if(x%2==0) {
                this.data.set("老李","老李是个好人");
                
            }else {
                this.data.set("民族败类","老放b");
            }
        }
    }
}
class DataConsumer implements Runnable{
    private Data data;
    public DataConsumer(Data data) {
        this.data=data;
    }
    @Override
    public void run() {
        for(int x=0;x<50;x++) {
            this.data.get();
        }
    } 
}
class Data{//负责数据保存
    private String title;
    private String note;
    //flag=true 表示允许生产不允许消费者取走
    //flag=false 表示生产完毕允许消费者取走不允许生产
    private boolean flag=false;
    public synchronized void get() {
        if(this.flag==false) {//已经生产了，所以不允许重复生产
            try {
                super.wait();
            } catch (InterruptedException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            }//等待执行 
        }
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println(this.title+"="+this.note);
        this.flag=false;//表示生产过了。不允许再生产了
        super.notify();//唤醒等待线程
    }
    public synchronized void set(String title,String note) {
        if(this.flag==true) {//现在不允许取走
            try {
                super.wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        this.title=title;
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        this.note=note;
        this.flag=true;//继续生产
        super.notify();
    }
}
 

面试题：请解释sleep()与wait()的区别

　　sleep()是Thread类的方法到了一定的时间后该休眠自动唤醒

　　wait()是Object类中的方法，要想唤醒必须使用notify(),notifyAll()