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();

     }
 }