求生产者消费者问题的代码和解释

你这问题描述太笼统了……最好是把代码发上来。然后指出看不懂的地方

我来帮你回复吧！回复 了就休息的

1. package cn.itcast_07;
   
2. //在这个类中封装了设置和获取的方法（生产者和消费者）
   
3. public class Student {
   
4.         //定义的私有成员变量
   
5.         private String name;
   
6.         private int age;
   
7.         private boolean flag;
   
8.         //这个是在成员方法上加锁，其锁为this
   
9.         public synchronized void set(String name, int age) {
   
10.                 //首先为false
    
11.                 if (this.flag) {
    
12.                         try {
    
13.                                 this.wait();
    
14.                         } catch (InterruptedException e) {
    
15.                                 e.printStackTrace();
    
16.                         }
    
17.                 }
    
18. 
    
19.                 // 1@设置名字和年龄（先生产出来）
    
20.                 this.name = name;
    
21.                 this.age = age;
    
22. 
    
23.                 // 修改标记，叫醒下一个线程（单）
    
24.                 this.flag = true;
    
25.                 this.notify();
    
26.                 //有可能继续有使用权，到上面就会在if里睡觉（等待着被叫醒）
    
27.                 //必须由下面消费了才有可能在生产
    
28.         }
    
29.         //这里同理
    
30.         public synchronized void get() {
    
31.                 if (!this.flag) {
    
32.                         try {
    
33.                                 this.wait();
    
34.                         } catch (InterruptedException e) {
    
35.                                 e.printStackTrace();
    
36.                         }
    
37.                 }
    
38. 
    
39.                 //2@ 获取数据（消费）
    
40.                 System.out.println(this.name + "---" + this.age);
    
41. 
    
42.                 // 修改标记
    
43.                 this.flag = false;
    
44.                 this.notify();
    
45.                 //有可能继续有使用权，到上面就会在if里睡觉（等待着被叫醒）
    
46.                 //消费过了必须 先上面生产再消费
    
47.         }
    
48. }

复制代码

1. package cn.itcast_07;
   
2. //一个生产式的多线程
   
3. public class SetThread implements Runnable {
   
4. 
   
5.         private Student s;
   
6.         private int x = 0;
   
7. 
   
8.         public SetThread(Student s) {
   
9.                 this.s = s;
   
10.         }
    
11. 
    
12.         @Override
    
13.         public void run() {
    
14.                 while (true) {
    
15.                         if (x % 2 == 0) {
    
16.                                 s.set("中南海", 27);
    
17.                         } else {
    
18.                                 s.set("黄鹤楼", 30);
    
19.                         }
    
20.                         x++;
    
21.                 }
    
22.         }
    
23. }

复制代码

1. package cn.itcast_07;
   
2. //一个消费式的多线程
   
3. public class GetThread implements Runnable {
   
4.         private Student s;
   
5.         //有参构造
   
6.         public GetThread(Student s) {
   
7.                 this.s = s;
   
8.         }
   
9.         //重写run方法
   
10.         @Override
    
11.         public void run() {
    
12.                 while (true) {
    
13.                         s.get();
    
14.                 }
    
15.         }
    
16. }
    

复制代码

1. package cn.itcast_07;
   
2. public class StudentDemo {
   
3.         public static void main(String[] args) {
   
4.                 //创建资源
   
5.                 Student s = new Student();
   
6.                
   
7.                 //一个生产一个消费的类，传递的是其共同操作的资源，这样就可以在其类中调用资                //源s的2个被封装的方法了
   
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. }

复制代码

把Student的成员变量给私有的了。
把设置和获取的操作给封装成了功能，并加了同步。
设置或者获取的线程里面只需要调用方法。
我已经用其全部能力说清楚了！不是你不懂就是我不懂，舍其无它！！！