1. class Res {
   
2.         private String name;
   
3.         private String sex;
   
4.         boolean flag = false;
   
5. 
   
6.         public synchronized void set(String name, String sex) {
   
7.                 if (flag)
   
8.                         try {
   
9.                                 this.wait();
   
10.                         } catch (InterruptedException e) {
    
11.                                 e.printStackTrace();
    
12.                         }
    
13.                 this.name = name;
    
14.                 this.sex = sex;
    
15.                 flag = true;
    
16.                 this.notify();
    
17.         }
    
18. 
    
19.         public synchronized void out() {
    
20.                 if (!flag)
    
21.                         try {
    
22.                                 this.wait();
    
23.                         } catch (InterruptedException e) {
    
24.                                 e.printStackTrace();
    
25.                         }
    
26.                 System.out.println(this.name + "-------------" + this.sex);
    
27.                 flag = false;
    
28.                 this.notify();
    
29.         }
    
30. }
    
31. 
    
32. class Input implements Runnable {
    
33.         private Res r;
    
34. 
    
35.         Input(Res r) {
    
36.                 this.r = r;
    
37.         }
    
38. 
    
39.         public void run() {
    
40.                 boolean b = true;
    
41.                 while (true) {
    
42.                         if (b) {
    
43.                                 r.set("mike", "man");
    
44.                                 b=false;
    
45.                         } else {
    
46.                                 r.set("丽丽", "女女女女女");
    
47.                                 b=true;
    
48.                         }
    
49.                 }
    
50.         }
    
51. 
    
52. }
    
53. 
    
54. class Output implements Runnable {
    
55.         private Res r;
    
56. 
    
57.         Output(Res r) {
    
58.                 this.r = r;
    
59.         }
    
60. 
    
61.         public void run() {
    
62.                 while (true) {
    
63.                         r.out();
    
64.                         }
    
65.                 }
    
66.         }
    
67. 
    
68. 
    
69. public class InputOutputDemo {
    
70.         public static void main(String[] args) {
    
71.                 Res r = new Res();
    
72.                 new Thread(new Input(r)).start();
    
73.                 new Thread(new Output(r)).start();
    
74.                 /*
    
75.                 Input in = new Input(r);
    
76.                 Output out = new Output(r);
    
77.                 Thread t1 = new Thread(in);
    
78.                 Thread t2 = new Thread(out);
    
79.                 t1.start();
    
80.                 t2.start();*/
    
81.         }
    
82. }
    

复制代码

假设set函数拿到了执行权和this锁,进入函数体内时如果flag为true则会进入等待,但这时set函数没有释放锁,则out函数也无法进入,线程不是卡死了吗..为什么还能运行.

public synchronized void out() {

20.                if (!flag)

21.                        try {

22.                                this.wait(); //如果flag为true只是不会执行这一句而已,下面那句可以执行，同一段代码被锁锁上别的线程就不能进来，但这是两段不同的代码

23.                        } catch (InterruptedException e) {

24.                                e.printStackTrace();

25.                        }

26.                System.out.println(this.name + "-------------" + this.sex);

27.                flag = false;

28.                this.notify();

29.        }

1. public synchronized void set(String name, String sex) {
   
2.                 if (flag)   //flag为false,还没有进入等待，直接执行this.name=name......
   
3.                         try {
   
4.                                 this.wait();
   
5.                         } catch (InterruptedException e) {
   
6.                                 e.printStackTrace();
   
7.                         }
   
8.                 this.name = name;
   
9.                 this.sex = sex;
   
10.                 flag = true;//将flag设置为true
    
11.                 this.notify();//唤醒线程
    
12.         }
    
13. 
    
14.         public synchronized void out() {
    
15.                 if (!flag)//!flag为false,不进入等待，直接执行输出语句。
    
16.                         try {
    
17.                                 this.wait();
    
18.                         } catch (InterruptedException e) {
    
19.                                 e.printStackTrace();
    
20.                         }
    
21.                 System.out.println(this.name + "-------------" + this.sex);
    
22.                 flag = false;//将flag设置为false
    
23.                 this.notify();//唤醒线程
    
24.         }
    
25. }

复制代码

我上面注释的是第一次执行的时候，执行到最后那唤醒线程时，要是想再次执行本线程，由于加了条件判断，会让它睡去，所以这样就能保证你设置一次打印一次！

若还有问题，请继续追问；没有的话，请将帖子分类改成【已解决】~

谢洋 发表于 2013-3-19 23:24
public synchronized void out() {

20.                if (!flag)

你可能误解我的意思了.我问的是当out持有this锁的时候如果进入睡眠,锁还没释放,那么set拿不到this锁无法进入线程,也就无法把out唤醒了吗...

假设set函数拿到了执行权和this锁,进入函数体内时如果flag为true则会进入等待,当执行this.wait()方法时会解除当前对象的锁定，自然out方法就可以执行了

谢达 发表于 2013-3-20 08:34
假设set函数拿到了执行权和this锁,进入函数体内时如果flag为true则会进入等待,当执行this.wait()方法时会解 ...

谢谢...原来在执行wait方法前解除了对当前对象的锁定...终于明白了