黑马程序员技术交流社区

标题: 线程问题 [打印本页]
作者: 刘潘敏    时间: 2015-4-9 01:16
标题: 线程问题
求生产者消费者问题的代码和解释
作者: 君嘘    时间: 2015-4-9 01:49
你这问题描述太笼统了……最好是把代码发上来。然后指出看不懂的地方
作者: 吴飞飞    时间: 2015-4-9 02:34
我来帮你回复吧！回复 了就休息的
  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.                 }

  19.                 // 1@设置名字和年龄（先生产出来）
  20.                 this.name = name;
  21.                 this.age = age;

  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.                 }

  39.                 //2@ 获取数据（消费）
  40.                 System.out.println(this.name + "---" + this.age);

  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 {

  5.         private Student s;
  6.         private int x = 0;

  8.         public SetThread(Student s) {
  9.                 this.s = s;
  10.         }

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

  11.                 //线程类
  12.                 Thread t1 = new Thread(st);
  13.                 Thread t2 = new Thread(gt);

  15.                 //启动线程
  16.                 t1.start();
  17.                 t2.start();
  18.         }
  19. }
复制代码
把Student的成员变量给私有的了。
把设置和获取的操作给封装成了功能，并加了同步。
设置或者获取的线程里面只需要调用方法。
我已经用其全部能力说清楚了！不是你不懂就是我不懂，舍其无它！！！



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2