如果是生产多个，和消费多个的话，两个线程需要加上同一把锁才行。
    但是这样做依然还存在着问题：
            1.如果消费者先抢到CPU执行权，消费数据，这时数据如果是空，就没有意义。
                应该等着数据生产出来，再去消费，这样才具有意义。
            2.如果生产者先抢到CPU执行权，生产数据，但是生产完一定数量的数据以后，还继续持有执行权，
                它还会继续生产数据，这还现实情况不符，需要等着消费者把数据消费以后，再生产。
   
    正常思路：
            1.生产者
                    先看是否有数据，有就等待，没有就生产，生产完通知消费者消费
            2.消费者
                    先看是否有数据，有就消费，没有就等待，消费完通知生产者生产
                    
java提供了一个等待唤醒机制来解决这个问题。

* 等待唤醒：
*         Object类中提供了三个方法：
*                 wait():等待
*                 notify():唤醒单个线程
*                 notifyAll():唤醒多个线程
*         为什么等待唤醒方法定义在Object类中：
*                 这些方法都是通过锁对象进行调用的，锁对象可以是任意的
*                 所以，这些方法必须定义在Object类中。
测试类：

1. package com.kxg_03;
   
2. public class StudentDemo {
   
3.         public static void main(String[] args) {
   
4.                 // 创建资源
   
5.                 Student s = new Student();
   
6. 
   
7.                 // 创建SetThread和GetThread对象
   
8.                 SetThread st = new SetThread(s);
   
9.                 GetThread gt = new GetThread(s);
   
10. 
    
11.                 // 创建线程
    
12.                 Thread t1 = new Thread(st);
    
13.                 Thread t2 = new Thread(gt);
    
14. 
    
15.                 // 开启线程
    
16.                 t1.start();
    
17.                 t2.start();
    
18.         }
    
19. }

复制代码

资源类：

1. package com.kxg_03;
   
2. /*
   
3. * 定义学生类
   
4. */
   
5. public class Student {
   
6.         String name;
   
7.         int age;
   
8.         boolean flag;// 用来判断是否存在资源，默认是flash，没有资源
   
9. }

复制代码

生产者类：

1. package com.kxg_03;
   
2. 
   
3. /*
   
4. * 设置学生信息的线程
   
5. */
   
6. public class SetThread implements Runnable {
   
7. 
   
8.         private Student s;
   
9.         private int i;
   
10. 
    
11.         public SetThread(Student s) {
    
12.                 this.s = s;
    
13.         }
    
14.         @Override
    
15.         public void run() {
    
16.                 while (true) {
    
17.                         // 设置同步锁
    
18.                         synchronized (s) {
    
19.                                 // 如果有数据，生产者等待
    
20.                                 if (!s.flag) {
    
21.                                         try {
    
22.                                                 s.wait();
    
23.                                         } catch (InterruptedException e) {
    
24.                                                 e.printStackTrace();
    
25.                                         }
    
26.                                 }
    
27. 
    
28.                                 if (i % 2 == 0) {
    
29.                                         s.name = "小明";
    
30.                                         s.age = 5;
    
31.                                 } else {
    
32.                                         s.name = "汪汪";
    
33.                                         s.age = 2;
    
34.                                 }
    
35.                                 i++;
    
36.                                 // 生产完成，把变量改为有数据
    
37.                                 s.flag = false;
    
38.                                 // 唤醒线程
    
39.                                 s.notify();
    
40.                         }
    
41.                 }
    
42.         }
    
43. }
    

复制代码

消费者类：

1. package com.kxg_03;
   
2. 
   
3. /*
   
4. * 设置获取学生信息的线程
   
5. */
   
6. public class GetThread implements Runnable {
   
7. 
   
8.         private Student s;
   
9. 
   
10.         public GetThread(Student s) {
    
11.                 this.s = s;
    
12.         }
    
13.         @Override
    
14.         public void run() {
    
15.                 while (true) {
    
16.                         // 设置同步锁
    
17.                         synchronized (s) {
    
18.                                 // 如果没有数据，消费者就等待
    
19.                                 if (s.flag) {
    
20.                                         try {
    
21.                                                 s.wait();
    
22.                                         } catch (InterruptedException e) {
    
23.                                                 e.printStackTrace();
    
24.                                         }
    
25.                                 }
    
26.                                 System.out.println(s.name + "：" + s.age);
    
27.                                 // 修改标记
    
28.                                 s.flag = true;
    
29.                                 // 唤醒线程
    
30.                                 s.notify();
    
31.                         }
    
32.                 }
    
33.         }
    
34. }

复制代码