java当前线程等待5秒_Java多线程5-线程等待与唤醒

1、wait()，notify()，notifyAll()等方法介绍

在object.java中，定义了wait()，notify()，notifyAll()等接口。wait()的作用是让当前线程进入等待状态，同时，wait()也会让当前线程释放它所持有的锁。而notify()和notifyAll()的作用，则是唤醒当前对象上的等待线程；notify()是唤醒单个线程，而notifyAll()是唤醒所有的线程。

object类中关于等待/唤醒的API详细信息如下：

notify():唤醒在此对象监视器上等待的单个线程。

notifyAll():唤醒在此对象监视器上等待的所有线程。

wait():让当前线程处于“等待/阻塞”状态，直到其他线程调用此对象的notify()或notifyAll()方法，当前线程被唤醒(进入“就绪态”)。

wait(long timeout):让当前线程处于“等待/阻塞”状态，直到其他线程调用此对象的notify()方法或notifyAll()方法，或者其他某个线程终端当前线程，或者已超过某个实际时间量，当前线程被唤醒(进入就绪态)。

2、wait()和notify()实例

下面通过示例演示“wait()和notify()使用的情形”

class ThreadA extendsThread

{publicThreadA(String name)

{super(name);

}public voidrun()

{synchronized(this)

{

System.out.println(Thread.currentThread().getName()+" call notify()");

notify();

}

}

}public classWaitTest

{public static voidmain(String[] args)

{

ThreadA t1= new ThreadA("t1");synchronized(t1)

{try{

System.out.println(Thread.currentThread().getName()+" start t1");

t1.start();

System.out.println(Thread.currentThread().getName()+" wait()");

t1.wait();

System.out.println(Thread.currentThread().getName()+" continue");

}catch(InterruptedException ie)

{

ie.printStackTrace();

}

}

}

}

运行结果为：

main start t1

main wait()

t1 call notify()

maincontinue

结果说明：

1、主线程通过new ThreadA("t1")新建线程t1。随后通过synchronized(t1)获取“t1”对象的同步锁，然后调用t1.start()启动线程t1

2、主线程执行t1.wait()释放t1对象的锁，并且进入等待(阻塞)状态。等待t1对象上的线程通过notify()或者notifyAll()将其唤醒

3、线程t1运行之后，通过synchronized(this)获取“当前对象”的锁，接着调用notify()唤醒当前对象上的等待线程，也就是唤醒主线程

4、线程t1运行完毕之后，释放“当前对象的锁”。紧接着，主线程获取t1对象的锁，然后接着运行

3、wait(long timeout)和notify()

wait(long timeout)会让当前线程处于“等待/阻塞”状态，“直到其他线程调用此对象的notify()方法或者notifyAll()方法，或者超过指定的时间量”，当前线程被唤醒。

下面是示例：

class ThreadA extendsThread

{publicThreadA(String name)

{super(name);

}public voidrun()

{

System.out.println(Thread.currentThread().getName()+" run ");while(true)

;

}

}public classWaitTimeoutTest

{public static voidmain(String[] args)

{

ThreadA t1= new ThreadA("t1");synchronized(t1)

{try{

System.out.println(Thread.currentThread().getName()+" start t1");

t1.start();

System.out.println(Thread.currentThread().getName()+" wait()");

t1.wait(3000);

System.out.println(Thread.currentThread().getName()+" continue");

}catch(InterruptedException ie)

{

ie.printStackTrace();

}

}

}

}

运行结果：

main start t1

main wait()

t1 run

maincontinue //上一句三秒后输出这一句

结果说明：

1、主线程main通过执行t1.start()启动线程t1

2、主线程main执行t1.wait(3000)，此时，主线程进入阻塞状态。需要用于t1对象锁的线程通过notify()或者notifyAll()将其唤醒或者超时3000ms，主线程main才能进入就绪状态

3、线程t1运行之后，陷入死循环

4、超过3000ms之后，主线程进入就绪态，然后进入运行状态

4、wait()和notifyAll()

现在演示notifyAll()的用法，它的作用是唤醒在此对象监视器上的所有线程

public classWaitTimeoutTest

{private static Object obj = newObject();public static voidmain(String[] args)

{

ThreadA t1= new ThreadA("t1");

ThreadA t2= new ThreadA("t2");

ThreadA t3= new ThreadA("t3");

t1.start();

t2.start();

t3.start();try{

System.out.println(Thread.currentThread().getName()+" sleep(3000)");

Thread.sleep(3000);

}catch(InterruptedException ie)

{

ie.printStackTrace();

}synchronized(obj)

{

System.out.println(Thread.currentThread().getName()+" notifyAll");

obj.notifyAll();

}

}static class ThreadA extendsThread

{publicThreadA(String name)

{super(name);

}public voidrun()

{synchronized(obj)

{try{

System.out.println(Thread.currentThread().getName()+" wait");

obj.wait();

System.out.println(Thread.currentThread().getName()+" continue");

}catch(InterruptedException ie)

{

ie.printStackTrace();

}

}

}

}

}

运行结果：

main sleep(3000)

t1 wait

t2 wait

t3 wait

main notifyAll

t3continuet2continuet1continue

结果说明：

1、主线程中新建并启动了三个线程t1，t2，t3

2、主线程通过sleep(3000)休眠3秒，在主线程休眠三秒的过程中，我们假设t1，t2，t3这三个线程都运行了。以t1为例，当他运行的时候，会执行obj.wait()等待其他线程通过notify()或者notifyAll()来唤醒它；相同的，t2和t3也会等待

3、主线程休眠3s以后，接着运行。执行obj.notifyAll()唤醒obj上的等待线程，即唤醒t1，t2，t3。紧接着，主线程的synchronized(obj)运行完毕之后，主线程释放“obj”锁，这样t1，t2，t3就可以接着运行了

5、为什么notify()，wait()等函数定义在object中，而不是Thread中

object中的wait()，notify()等函数，和synchronized一样，会对“对象的同步锁”进行操作。

wait()使当前进程等待，因为线程进入等待状态，所以线程应该释放它所持有的“同步锁”，否则其他线程获取不到该“同步锁”而无法运行

线程调用wait()之后，会释放它所持有的“同步锁”；而且，等待线程可以被notify()和notifyAll()唤醒。而notify()就是根据对象的同步锁唤醒线程的

负责唤醒等待线程的那个线程，他只有在获取“该对象的同步锁”(这里的同步锁必须和等待线程的同步锁是同一个，并且调用notify()或者notifyAll()方法之后，才能唤醒等待线程。虽然，等待线程被唤醒；但是，他不能立刻执行，因为唤醒线程还持有“该对象的同步锁”。必须等到唤醒线程释放了“该对象的同步锁”之后，等待线程才能获取到“对象的同步锁”，从而开始运行

总之，notify()，wait()依赖于“同步锁”，而“同步锁”是对象所持有的，并且每个对象有且只有一个。所以notify()和wait()定义在object类，而不是Thread类中。