关于多线程的wait和notify产生的问题。

Question

 class Maintest {
    public static void main(String args[]) throws Exception {
        ThreadDemo thr = new ThreadDemo();
        thr.start();
        for (int i = 1; i < 1000; i++) {
            synchronized (Maintest.class) {  //Maintest.class是什么意思，非常不明白
                System.out.println("main: " + i);
                Maintest.class.notify();  //这个与下边怎么联系？
                Maintest.class.wait();
            }
        }    }
}class ThreadDemo extends Thread {
    public void run() {
        for (int i = 1; i < 1000; i++) {
            try {
                synchronized (Maintest.class) {                      System.out.println(this.getName() + ":" + i);
                    Maintest.class.notify();
                    Maintest.class.wait();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Answer 1

Maintest.class就是一个对象，用这个对象作为锁，只有获取到这个对象以后才能访问synchronized块中的内容。
wait的时候会释放该对象锁，通过这个对象wait的线程在该对象调用notify的时候会被唤醒不知道说明白了没有

Answer 2

我看完了 是这样的Maintest.class 这种东西叫 类字面常量
他是用来生成对class对象的引用 说白了Maintest.class在这里就是一个锁 就跟用String "aaa" 或者this一样
 
synchronized(o){}  o.notify();   o.wait(); 这个3个东西用同一个锁所以就需要 
synchronized (Maintest.class) {  
                System.out.println("main: " + i);
                Maintest.class.notify();  
              }而你可以注意到在2个线程中的synchronized代码块用的锁是同一个就是Maintest.class这个对象的引用然后代码也可以这样写（换一个锁） 效果一样
public class MainTest {
    public static void main(String args[]) throws Exception {
        Lock lock = new Lock();
        ThreadDemo thr = new ThreadDemo(lock);
        thr.start();
        for (int i = 1; i < 1000; i++) {
            synchronized (lock) {  
                System.out.println("main: " + i);
                lock.notify();  
                lock.wait();
            }
        }    }
}class ThreadDemo extends Thread {
Lock lock;
public ThreadDemo(Lock lock){this.lock = lock;}
    public void run() {
        for (int i = 1; i < 1000; i++) {
            try {
                synchronized (lock) {                      
                 System.out.println(this.getName() + ":" + i);
                 lock.notify();
                 lock.wait();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}class Lock{}

Answer 3

Maintest.class 这个是‘锁’是在锁上面做同步的。线程判断是否可以进入代码块的时候先看看锁是否开的，就像房门是否是开的。房门同一时间只能进入一个人
进屋后，有人wait就是关门，睡觉
有人notify就是开门先开门在睡觉
lock.notify();  
lock.wait();
关门的时机是wait这行代码执行结束
开门的时机是synchronized {}结束，或者执行wait
 

Answer 4

呵呵，正好那天看到java内部执行初始化的时候就是用本类的Class对象作为锁，挺好玩的。

Answer 5

忘了讲出门
代码块结束了就是人从屋子里面出来了
只有一种情况屋子里面会有两个人
就是第一个人睡觉了，第二个人才可以进去，刚才讲了，wait也是可以开门的不同的锁可以理解为同一个屋子的 镜像，他们彼此是隔离的
就是锁同一个代码块可以是不同的锁，虽然是同一个代码块，但是一定要把不同的锁当成不通的屋子为什么锁会不同，这个很简单了
synchronized （变量）
是变量当然就会不同了，不知道例子举得好不好，明白了吗？

Answer 6

恩，是三楼的说法~
那个Maintest.class可以随便更换为一对象，同一对象只有一把对应的锁
利用该对象锁来进行 wait与notify,
其实一般的问题比这要复杂，通常有多个不同的线程挂在一把锁上~
不说了~感觉一说就象打开自己记忆一样，停不下来`~

Answer 7

汗，刚在写test自己回忆就这么一群回复了，偶先睡觉了~明天老班查课，不得不去

Answer 8

鄙视，同时无语中。这么x大点事。 
http://topic.csdn.net/u/20081004/09/19666f3a-9f12-4f4f-8740-04beb65009da.html
参8楼