1. package justForTest;
   
2. 
   
3. 
   
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. }
    
13. 
    
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.                          }
    
35. 
    
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. }
    
83. 
    
84. //定义资源类
    
85. class resource
    
86. {
    
87.          String name;
    
88.          String sex;
    
89.          boolean flag=false;
    
90. 
    
91. }
    

复制代码

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

下面是修改后的代码：

1. package justForTest;
   
2. 
   
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. }
   
10. 
    
11. // 存入资源线程
    
12. class Input implements Runnable {
    
13.         private resource r;
    
14. 
    
15.         Input(resource r) {
    
16.                 this.r = r;
    
17.         }
    
18. 
    
19.         public void run() {
    
20.                 int i = 0;
    
21. 
    
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.                                 }
    
31. 
    
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. }
    
48. 
    
49. // 取出资源线程
    
50. class Output implements Runnable {
    
51.         private resource r;
    
52. 
    
53.         Output(resource r) {
    
54.                 this.r = r;
    
55.         }
    
56. 
    
57.         public void run() {
    
58. 
    
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.                                 }
    
68. 
    
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. }
    
78. 
    
79. // 定义资源类
    
80. class resource {
    
81.         String name;
    
82.         String sex;
    
83.         boolean flag = false;
    
84. }

复制代码

为什么运行会报错··！


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

wait()在 放在了同步代码块外面

多线程访问统一资源会产生线程死锁的问题，需要考虑线程锁的问题，同一资源必须同时由一个线程锁定

嗯嗯！ 楼上说的对 synchronized语句写的位置问题

wait的位置不对，同步锁对象调用wait方法后，退出同步代码区，释放同步锁。其他的线程可以进去同步区，直到notify唤醒被阻塞的线程
你的程序注释都没有

应该对同一资源进行同步代码块处理

1. package cn.itcast.itscores;
   
2. 
   
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.         }
    
12. 
    
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.                                  }
    
35. 
    
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.         }
    
82. 
    
83.         //定义资源类
    
84.         class resource
    
85.         {
    
86.                  String name;
    
87.                  String sex;
    
88.                  boolean flag = false;
    
89. 
    
90.         }
    
91. 
    
92. 
    

复制代码

如果当前线程不是锁的持有者，该方法抛出一个IllegalMonitorStateException异常。

共享数据必须都放在同步代码块中.

wait()的位置不对

当前线程必是锁的持有者，不然会有异常