Java多线程基础 线程的等待与唤醒(wait、notify、notifyAll)

本篇我们来研究一下 wait() notify() notifyall() 。
demo1： wait() 与 notify()

public class test {

 static class threadone extends thread {

  private callback mcallback;

  @override
  public void run() {
   work();
   if (mcallback != null) {
    mcallback.onresult(false);
   }
  }

  // 耗时 3s
  private void work() {
   system.out.println(" 正在查询数据库 1");
   long starttime = system.currenttimemillis();
   while (true) {
    if (system.currenttimemillis() - starttime < 3000) {
     continue;
    }
    break;
   }
  }

  public void setcallback(callback callback) {
   mcallback = callback;
  }

  public interface callback {
   void onresult(boolean result);
  }
 }

 static class threadtest extends thread {

  private object mlock = new object();

  private threadone mthreadone;

  @override
  public void run() {
   workone();
   system.out.println(" 根据结果继续做其他事情 ");
  }

  private void workone() {
   mthreadone = new threadone();
   mthreadone.setcallback(new threadone.callback() {
    @override
    public void onresult(boolean result) {
     system.out.println(" 查询数据库 1 结束，:" + (result ? " 有数据 " : " 无数据 "));
     synchronized (mlock) {
      mlock.notify();
      system.out.println("--threadtest 结束等待 --");
     }
    }
   });
   mthreadone.start();
   try {
    synchronized (mlock) {
     system.out.println("--threadtest 进入等待 --");
     mlock.wait();
    }
   } catch (interruptedexception e) {
    e.printstacktrace();
   }
  }
 }

 public static void main(string[] var0) {
  threadtest threadtest = new threadtest();
  threadtest.start();
 }
}

demo1 输出：

--threadtest 进入等待--
正在查询数据库 1
查询数据库 1 结束，: 无数据
--threadtest 结束等待--
根据结果继续做其他事情

注意：
使用 wait() 和 notify() 必须在获得同步锁后才能调用，若直接调用会报 java.lang.illegalmonitorstateexception 错误，因为状态由同步锁保护。

wait() 不同于 sleep() 的是 wait() 会释放同步锁。

因为 wait() 和 notify() 是基于同步锁实现的，每个对象都有自己的同步锁，所以 wait() 和 notify() 是 object 的方法，而不是 thread。

demo2，wait() 与 notifyall()：

public class test {

 private static object mlock = new object();

 static class mythread extends thread {

  string mname;
  callback mcallback;

  public mythread(string name){
   mname = name;
  }

  @override
  public void run() {
   work();
   if (mcallback != null) {
    mcallback.onresult(false);
   }
  }

  // 耗时 3s
  private void work() {
   system.out.println(mname + " 等待 ");
   try {
    synchronized (mlock) {
     mlock.wait();
    }
   } catch (interruptedexception e) {
    e.printstacktrace();
   }
  }

  public void setcallback(callback callback) {
   mcallback = callback;
  }

  public interface callback {
   void onresult(boolean result);
  }
 }

 static class threadtest extends thread {



  @override
  public void run() {
   work("db1");
   work("db2");
   work("db3");

   try {
    sleep(2000);
   } catch (interruptedexception e) {
    e.printstacktrace();
   }

   synchronized (mlock) {
    system.out.println(" 唤醒全部 ");
    mlock.notifyall();
   }
  }

  private void work(string name) {
   final mythread mythread = new mythread(name);
   mythread.setcallback(new mythread.callback() {
    @override
    public void onresult(boolean result) {
     system.out.println(mythread.mname + " 回来了 ");
    }
   });
   mythread.start();
  }
 }

 public static void main(string[] var0) {
  threadtest threadtest = new threadtest();
  threadtest.start();
 }
}

demo2 输出：

db1 等待
db3 等待
db2 等待
唤醒全部
db3 回来了
db1 回来了
db2 回来了

同一个对象的 wait() 方法可多次在不同的线程中调用，可让不同的线程进入等待（阻塞），可以一个一个 notify()，也可以调用 notifyall() 一次性全部唤醒。