Java 实践：生产者与消费者

实践项目：生产者与消费者【经典多线程问题】

问题引出：

　　生产者和消费者指的是两个不同的线程类对象，操作同一个空间资源的情况。

需求引出：

　　—— 生产者负责生产数据，消费者负责取走数据

　　—— 生产者生产完一组数据之后，消费者就要取走一组数据

设置三个类：数据类、生产类、消费类；生产和消费类是线程类，同时操作同一个数据类；生产类负责每次向数据类中写入一组数据；消费类负责每次从数据类中取出一组数据。

package hello;

class Info {  // 数据类
    private String title ;
    private String content;
    public void setTitle(String title) {
        this.title = title ; 
    }
    public String getTitle() {
        return title ;
    }
    public String getContent() {
        return content ;
    }
    public void setContent(String content) {
        this.content = content ;
    }
    
}

class Producer implements Runnable { // 生成者类（线程）
    private Info info ;
    public Producer(Info info) {
        this.info = info ;
    }
    @Override
    public void run() {
        for (int x = 0 ; x < 100 ; x ++ ) {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if ( x % 2 == 0 ) {
                this.info.setTitle("张三");
                this.info.setContent("男");
            } else {
                this.info.setTitle("王五");
                this.info.setContent("男");
            }
        }
    }
}

class Consumer implements Runnable {
    private Info info ; 
    public Consumer(Info info) {
        this.info = info ;
    }
    @Override
    public void run() {
        for (int x = 0 ; x < 100 ; x ++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(this.info.getTitle() + "——" + this.info.getContent());
        }
    }
}

public class TestDemo {
    public static void main(String[] args) throws Exception {
        Info info = new Info() ;
        new Thread(new Producer(info)).start();
        new Thread(new Consumer(info)).start();
    }
}

 上例程序执行后，会发现“错位的现象”；出现类似数据为取走，就存入新的数据的错误。【不同步且异步现象导致】

package hello;

class Info {  // 数据类
    private String title ;
    private String content;
    public synchronized void set(String title , String content) {
        this.title = title ;
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
 
        this.content = content ;
    }
    public synchronized void get() {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(this.title + "——" + this.content);
    }
    
}

class Producer implements Runnable { // 生成者类（线程）
    private Info info ;
    public Producer(Info info) {
        this.info = info ;
    }
    @Override
    public void run() {
        for (int x = 0 ; x < 100 ; x ++ ) {                              
            if ( x % 2 == 0 ) {
                this.info.set("张三", "男");
            } else {
                this.info.set("李悦", "女");
            }
        }
    }
}

class Consumer implements Runnable {
    private Info info ; 
    public Consumer(Info info) {
        this.info = info ;
    }
    @Override
    public void run() {
        for (int x = 0 ; x < 100 ; x ++) {
            this.info.get();
        }
    }
}

public class TestDemo {
    public static void main(String[] args) throws Exception {
        Info info = new Info() ;
        new Thread(new Producer(info)).start();
        new Thread(new Consumer(info)).start();
    }
}

通过“同步方法”，解决了数据不同步的问题，但是于此而来的问题就是：数据的重复操作。

针对上两例程序，我们通过Object类的支持，来解决数据重复操作的问题：
　　如果像上例的设计，需要在程序中加入一个等待机制；当数据未取则等待数据取出后在存入，当数据未存等待数据存入后取出。而Object类中提供有专门的“等待”。

等待：    public final void wait() throws InterruptedException

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

唤醒全部的等待进入：    public final void notifyAll();  //优先级高越有可能先唤醒

通过Object的线程等待和唤醒功能完善程序：

package hello;

class Info {  // 数据类
    private String title ;
    private String content;
    private boolean flag = true ;
    // true:表示可以生产，不可以取走
    // false：表示不可以生产，可以取走
    public synchronized void set(String title , String content) {
        if (this.flag == false) { // 发现不可以生产，则等待线程
            try {
                super.wait();  // 通过super调用自己的超类（父类）Object类中的wait()方法等待线程
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.title = title ;
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.content = content ;
        this.flag = false ;// 修改标记
        super.notify(); //唤醒其他等待线程
    }
    public synchronized void get() {
        if (this.flag == true) {
            try {
                super.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(this.title + "——" + this.content);
        this.flag = true ; //修改标记
        super.notify(); // 唤醒其他线程
    }
    
}

class Producer implements Runnable { // 生成者类（线程）
    private Info info ;
    public Producer(Info info) {
        this.info = info ;
    }
    @Override
    public void run() {
        for (int x = 0 ; x < 100 ; x ++ ) {                              
            if ( x % 2 == 0 ) {
                this.info.set("张三", "男");
            } else {
                this.info.set("李悦", "女");
            }
        }
    }
}

class Consumer implements Runnable {
    private Info info ; 
    public Consumer(Info info) {
        this.info = info ;
    }
    @Override
    public void run() {
        for (int x = 0 ; x < 100 ; x ++) {
            this.info.get();
        }
    }
}

public class TestDemo {
    public static void main(String[] args) throws Exception {
        Info info = new Info() ;
        new Thread(new Producer(info)).start();
        new Thread(new Consumer(info)).start();
    }
}

 我们依靠Object类中的等待唤醒机制完成了代码的要求。

------------------------