我的线程不能唤醒！

Question

如果要唤醒进程不能使用interrupt方法中断进程，这样没法在唤醒
要让进程等待建议只是用wait()
在thinking in java中说：sleep和suspend不建议使用，因为容易使程序陷入死锁
他们再让进程等待的时候不释放共享资源。而使用wait会释放共享资源

Answer 1

你犯了一个错误。
你的匿名thread中的run方法中的synchronized(this), 这里的this
和jbutton2_xxx方法中的this不是一个东西.
前者只的是匿名类,后者是不是你的界面呀?总之不着两个不是一个对象.
那你等待,唤醒当然没有用了. 你可以把前者的this改为 类名.this 即 UI.this
试试吧.

Answer 2

这样没必要调用interrupt（）吧！
注：suspend（）这个方法已经作废了！

Answer 3

我想biti_9512207(波波斯基)说的对。必须是同一个对象才行。
你可以这样想，notifyAll只能够唤醒在同一个对象实例上wait的线程。
如果你非要达到那个效果，下面是修改的代码：
//在你的UI类里面添加，一个内部类叫ThreadTest。并且增加一个数据成员叫做test。
ThreadTest test = new ThreadTest(); class ThreadTest
  {
    public void waitUntil()
    {
      try {
        synchronized(this){
          wait(10000);
          System.out.println("Hello!");
        }
      }catch(InterruptedException e){}
    }    public synchronized void wakeup()
    {
      notifyAll();
    }
  }//然后，修改你的两个Button响应事件：
void jButton1_actionPerformed(ActionEvent e) {
      for (int i = 0; i < 2; i++)
      {
         new Thread(){
           public void run()
           {
             test.waitUntil();
           }
         }.start();
      }
  }void jButton2_actionPerformed(ActionEvent e) {
    synchronized(this){
            System.out.println("I am notifying everybody!");
            test.wakeup();
       }
  }你再试试吧！

Answer 4

Thread[] threads = new Thread[2];
    void jButton1_actionPerformed(ActionEvent e)
    {
        for(i=0; i<2; i++ ){
            threads[i] = new Thread()
            {
                public void run()
                {
                    synchronized(this){
                        this.wait(1000*60*10);
                        System.out.println("hello world");
                     }
                     this.interrupt();
                 }
            };
            threads[i].start();
        }
    }    void jButton2_actionPerformed(ActionEvent e)
    {
        for (int i=0;i<threads.length;i++){
        synchronized(threads[i]){
            threads[i].notifyAll();
        }
        }
    }

Answer 5

问题是这样产生的：
                 synchronized(this){
                        this.wait(1000*60*10);
                        System.out.println("hello world");
                     }
首先，你的程序获取this这个对象（也就是当前对象）的排它性使用权，然后，调用wait()。使当前线程在这this对象上wait,并且会放弃对这个对象的排它性使用权。
这个时候，你如果在另一个线程中，获取该对象的排它性使用权，调用它的notifyAll方法.这样你才能。唤醒在这个对象上wait的其他线程。象你原来的实现，因为你在notifyAll方法和wait方法获取的排它性使用权的对象，并不是同一个对象。一个是匿名的内部类对象，另一个是jFrame对象。当然，无法唤醒了!!所以请深刻理解synchronized(this)的含义。如果对线程有兴趣，去看看这篇文章：
http://www.csdn.net/develop/article/17/17290.shtm

Answer 6

while(true)
        {
            new Thread()
            {
                public void run()
                {
                    if( i++ > 3 ){
                        synchronized(this){
                            this.notify();
                            return;
                        }
                    }                    synchronized(this){
                        this.wait();
                    }
                    System.out.println("hello world");
                }
            }.start();
        }
那这样为什么也不能唤醒啊？ this 不是当前线程吗 ？

Answer 7

this的当前线程是new Thread()这个线程
你用new Thread()这个对象锁，锁住线程，却用别的对象锁来唤醒，当然不行。

Answer 8

你是什么意思呀！在同一个线程上先notify(),再永久的wait()？
看不懂了！

Answer 9

同意Norwaywoods() 的说法。
试着不要将this同步，换个对象试试！！