黑马程序员技术交流社区

标题: 多线程操作同一资源 运行报错！ [打印本页]
作者: 158803629    时间: 2015-7-28 16:22
标题: 多线程操作同一资源 运行报错！
  1. package justForTest;


  4. class  threadAccess
  5. {    //两个线程同时访问一个资源
  6.         public static void main(String[] args)
  7.         {
  8.         resource r=new resource();
  9.                 new Thread(new input(r)).start();
  10.                 new Thread(new output(r)).start();
  11.         }
  12. }

  14. //存入资源线程
  15. class input implements Runnable
  16. {
  17.         private resource r;
  18.         input(resource r){
  19.          this.r=r;
  20.         }
  21.          public void run(){
  22.                  int i=0;
  23.                  
  24.                  while(true){
  25.                          if(r.flag){
  26.                                  try
  27.                                  {
  28.                                         r.wait();
  29.                                  }
  30.                                  catch (Exception e)
  31.                                  {
  32.                                          e.printStackTrace();
  33.                                  }
  34.                          }

  36.                          synchronized(r){
  37.                  if(i==0){
  38.                          r.name="liuliu";
  39.                          r.sex="nan";
  40.                  }
  41.                  else{
  42.                    r.name="yanyan";
  43.                    r.sex="lv";
  44.                  }
  45.          i=(1+i)%2;
  46.                  r.flag=true;
  47.                  r.notify();
  48.        }
  49.            }
  50.           
  51.          }
  52. }
  53. //取出资源线程
  54. class output implements Runnable
  55. {
  56.         private resource r;
  57.         output(resource r){
  58.          this.r=r;
  59.         }
  60.          public void run(){
  61.                  
  62.                  while(true){
  63.                          if(!r.flag){
  64.                                  try
  65.                                  {
  66.                                         r.wait();
  67.                                  }
  68.                                  catch (Exception e)
  69.                                  {
  70.                                          e.printStackTrace();
  71.                                  }}
  72.                                  
  73.                          synchronized(r){
  74.                      System.out.println(r.name+"::"+r.sex);
  75.                          r.flag=false;
  76.                          r.notify();
  77.                  }
  78.                   
  79.                  }
  80.           
  81.          }
  82. }

  84. //定义资源类
  85. class resource
  86. {
  87.          String name;
  88.          String sex;
  89.          boolean flag=false;

  91. }
复制代码


作者: nightingale    时间: 2015-7-28 16:22
首先，定义同步代码块的位置就不对，因为多线程操作共有数据时，要避免安全隐患，就需要对操作共用数据的部分进行同步，
而楼主的程序有定义标记flag，它是资源resource里的共有数据，也就是说，flag也是要放在同步代码快中。
其次，
wait():
notify();
notifyAll();
以上都使用在同步中，因为要对持有监视器(锁)的线程操作。
所以要使用在同步中，因为只有同步才具有锁。
简单点说，就是wait，notify，要放在同步代码块中才会起效，才会有意义。

下面是修改后的代码：
  1. package justForTest;

  3. public class ThreadAccess { // 两个线程同时访问一个资源
  4.         public static void main(String[] args) {
  5.                 resource r = new resource();
  6.                 new Thread(new Input(r)).start();
  7.                 new Thread(new Output(r)).start();
  8.         }
  9. }

  11. // 存入资源线程
  12. class Input implements Runnable {
  13.         private resource r;

  15.         Input(resource r) {
  16.                 this.r = r;
  17.         }

  19.         public void run() {
  20.                 int i = 0;

  22.                 while (true) {
  23.                         synchronized (r) {                //把同步代码块放到这里来。
  24.                                 if (r.flag) {
  25.                                         try {
  26.                                                 r.wait();        //wait()使线程等待的同时，还会把锁释放。
  27.                                         } catch (Exception e) {
  28.                                                 e.printStackTrace();
  29.                                         }
  30.                                 }

  32.                                 if (i == 0) {
  33.                                         r.name = "liuliu";
  34.                                         r.sex = "nan";
  35.                                 } else {
  36.                                         r.name = "yanyan";
  37.                                         r.sex = "lv";
  38.                                 }
  39.                                 i = (1 + i) % 2;
  40.                                 r.flag = true;
  41. //                                如果是多个input线程，这里就需要改成notifyAll，
  42. //                                因为单独的notify()可能唤醒的是其他input线程，导致程序停止。
  43.                                 r.notify();
  44.                         }
  45.                 }
  46.         }
  47. }

  49. // 取出资源线程
  50. class Output implements Runnable {
  51.         private resource r;

  53.         Output(resource r) {
  54.                 this.r = r;
  55.         }

  57.         public void run() {

  59.                 while (true) {
  60.                         synchronized (r) {                //把同步代码块放到这里来。
  61.                                 if (!r.flag) {
  62.                                         try {
  63.                                                 r.wait();        //wait()使线程等待的同时，还会把锁释放。
  64.                                         } catch (Exception e) {
  65.                                                 e.printStackTrace();
  66.                                         }
  67.                                 }

  69.                                 System.out.println(r.name + "::" + r.sex);
  70.                                 r.flag = false;
  71. //                                如果是多个output线程，这里就需要改成notifyAll，
  72. //                                因为单独的notify()可能唤醒的是其他output线程，导致程序停止。
  73.                                 r.notify();
  74.                         }
  75.                 }
  76.         }
  77. }

  79. // 定义资源类
  80. class resource {
  81.         String name;
  82.         String sex;
  83.         boolean flag = false;
  84. }
复制代码


作者: 158803629    时间: 2015-7-28 16:23
为什么运行会报错··！


yanyan::lv
        at java.lang.Object.wait(Native Method)
        at java.lang.Object.wait(Object.java:502)
        at justForTest.input.run(threadAccess.java:28)
        at java.lang.Thread.run(Thread.java:745)
java.lang.IllegalMonitorStateException
        at java.lang.Object.wait(Native Method)
        at java.lang.Object.wait(Object.java:502)
        at justForTest.output.run(threadAccess.java:66)
        at java.lang.Thread.run(Thread.java:745)
java.lang.IllegalMonitorStateException
        at java.lang.Object.wait(Native Method)
liuliu::nan
        at java.lang.Object.wait(Object.java:502)
        at justForTest.input.run(threadAccess.java:28)
        at java.lang.Thread.run(Thread.java:745)
java.lang.IllegalMonitorStateException
        at java.lang.Object.wait(Native Method)
        at java.lang.Object.wait(Object.java:502)
        at justForTest.output.run(threadAccess.java:66)
        at java.lang.Thread.run(Thread.java:745)
java.lang.IllegalMonitorStateException
yanyan::lv
        at java.lang.Object.wait(Native Method)
······




作者: liuch111    时间: 2015-7-28 16:39
wait()在 放在了同步代码块外面
作者: 铁蛋    时间: 2015-7-29 15:58
多线程访问统一资源会产生线程死锁的问题，需要考虑线程锁的问题，同一资源必须同时由一个线程锁定
作者: 小王在黑马    时间: 2015-7-29 16:36
嗯嗯！ 楼上说的对 synchronized语句写的位置问题
作者: 醉翁之意不在酒    时间: 2015-7-30 00:25
wait的位置不对，同步锁对象调用wait方法后，退出同步代码区，释放同步锁。其他的线程可以进去同步区，直到notify唤醒被阻塞的线程
你的程序注释都没有
作者: 崔宝文    时间: 2015-8-3 07:27
应该对同一资源进行同步代码块处理
作者: l_15562009298    时间: 2015-8-3 20:03
  1. package cn.itcast.itscores;

  3.         public class ThAccess {
  4.                 //两个线程同时访问一个资源
  5.                 public static void main(String[] args)
  6.                 {
  7.                 resource r=new resource();
  8.                         new Thread(new input(r)).start();
  9.                         new Thread(new output(r)).start();
  10.                 }
  11.         }

  13.         //存入资源线程
  14.         class input implements Runnable
  15.         {
  16.                 private resource r;
  17.                 input(resource r){
  18.                  this.r=r;
  19.                 }
  20.                  public void run(){
  21.                          int i=0;
  22.                          
  23.                          synchronized(r){
  24.                          while(true){
  25.                                  if(r.flag){
  26.                                          try
  27.                                          {
  28.                                                 r.wait();
  29.                                          }
  30.                                          catch (Exception e)
  31.                                          {
  32.                                                  e.printStackTrace();
  33.                                          }
  34.                                  }

  36.                          if(i==0){
  37.                                  r.name="lulu";
  38.                                  r.sex="male";
  39.                          }
  40.                          else{
  41.                            r.name="yanyan";
  42.                            r.sex="female";
  43.                          }
  44.                  i=(1+i)%2;
  45.                          r.flag=true;
  46.                          r.notify();
  47.                }
  48.                    }
  49.                   
  50.                  }
  51.         }
  52.         //取出资源线程
  53.         class output implements Runnable
  54.         {
  55.                 private resource r;
  56.                 output(resource r){
  57.                  this.r=r;
  58.                 }
  59.                  public void run(){
  60.                          
  61.                          while(true){
  62.                                  synchronized(r){
  63.                                  if(!r.flag){
  64.                                          try
  65.                                          {
  66.                                                 r.wait();
  67.                                          }
  68.                                          catch (Exception e)
  69.                                          {
  70.                                                  e.printStackTrace();
  71.                                          }}
  72.                                         
  73.                              System.out.println(r.name+"::"+r.sex);
  74.                                  r.flag=false;
  75.                                  r.notify();
  76.                          }
  77.                            
  78.                          }
  79.                   
  80.                  }
  81.         }

  83.         //定义资源类
  84.         class resource
  85.         {
  86.                  String name;
  87.                  String sex;
  88.                  boolean flag = false;

  90.         }


复制代码

如果当前线程不是锁的持有者，该方法抛出一个IllegalMonitorStateException异常。
作者: 朝花夕拾7    时间: 2015-8-3 21:35
共享数据必须都放在同步代码块中.
作者: yefeidd    时间: 2015-8-4 16:39
wait()的位置不对
作者: l_15562009298    时间: 2015-8-16 23:16
当前线程必是锁的持有者，不然会有异常



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