java多线程中的生产者与消费者之等待唤醒机制@Version1.0

 一、生产者消费者模式的学生类成员变量生产与消费demo，第一版
1、等待唤醒：
　　    Object类中提供了三个方法：
　　    wait():等待
   　　 notify():唤醒单个线程
   　　 notifyAll():唤醒所有线程
2、为什么这些方法不定义在Thread类中呢?
  　　 这些方法的调用必须通过锁对象调用，而我们刚才使用的锁对象是任意锁对象。
 　　 所以，这些方法必须定义在Object类中。
3、当我们在使用多线程的时候有的时候需要，一条线程产生一个数据，另一条线程接着消费一个数据，一边生产一边消费，既没有多余的数据产生，也没有的空的数据被消费。

4、问题解决方案第一步保证线程同步安全：（1）加锁，

 　　　A:不同种类的线程都要加锁。
　　　 B:不同种类的线程加的锁必须是同一把。

5、问题解决方案第二步保证数据的一次生产消费：（等待唤醒机制）。

6、在下面新建的两条线程，两条线程操作的对象都是学会类，一条线程生产学生对象的数据，一条线程消费学生对象的数据，且做到，有数据才消费，没数据就等待，没数据就生产，有数据就等待。

//==========================

//第一个案例是学生类对象，非常的简单就定义了两个成员变量，以及一个用于唤醒线程的标记。

public class Student {
    public String name;
    public int age;
    boolean flag;  //默认情况是false--->没有数据，如果是true说明有数据。
    
}

//下面的是生产者学生对象的demo

//在构造方法中传递了学生对象，保证生产者与消费者操作的是同一个对象。

public class setThread implements Runnable {
    private Student s;
    int x = 0;

    public setThread(Student s) {
        this.s = s;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (s) {
                // 唤醒机制，生产者，先判断有没有哦，有就等待被消费，没有就生产数据准备被消费。
                if (s.flag) {
                    try {
                        s.wait();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                
                //一旦flag标记为false就执行下面的代码
                
                if (x % 2 == 0) {
                    s.name = "java";
                    s.age = 25;
                } else {
                    s.name = "android";
                    s.age = 20;
                }
                x++;
                // 数据生产一次,此时有了数据需要修改标记，下一循环开始的时候，就暂时不在生产，
                s.flag = true;

                // 唤醒线程
                s.notify();
            }

        }
    }

}

//下面的是学生对象的消费者模式demo

//在构造方法中传递了学生对象，保证生产者与消费者操作的是同一个对象。

public class getThread implements Runnable {
    private Student s;

    public getThread(Student s) {
        this.s = s;
    }

    public void run() {
        while (true) {
            // 唤醒机制 消费者，有数据就消费，没有数据(!)就等待数据被生产。
            // 吐过没有就等待，有就消费
            synchronized (s) {
                if (!s.flag) { //flag--->false执行if下面的代码：表示没有数据就等待
                    try {
                        s.wait();  //在等待的时候立即释放锁，方便其他的线程使用锁。而且被唤醒时，就在此处唤醒，
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }

                // flag--->true：消费数据
                System.out.println(s.name + "   " + s.age);
                // 消费完毕后，数据没有了，修改标记
                s.flag = false;
                // 唤醒线程
                //唤醒并不代表你立即可以得到执行权，此时仍然需要抢CPU的执行权，
                s.notify();   
            }
        }
    }
}

//下面的是测试用例，就是简单的创建了两条线程，然后启动刚才的生产者与消费者

/*
 * 如何在同一个包下，多个类中共享一个数据：
 *         在外界把这个数据创建出来，然后通过构造方法传递给其它的类。
 */
public class Demo {
    public static void main(String[] args) {
        // 共享数据，外界创建，作为参数，通过构造共有
        Student s = new Student();
        // 在构造中使用同一个参数
        setThread st = new setThread(s);
        getThread gt = new getThread(s);

        Thread t1 = new Thread(st);// 设置数据
        Thread t2 = new Thread(gt); // 获取数据

        t2.start();
        t1.start();

    }
}