这三个方法是java的基础类Object中定义的。
Java所有的类都具有线程的潜力,Java赋予的每个对象一个锁,在计算机内部工作在同一时间,只有一个对象可以持有锁,也就是说程序在同一时间只有一个程序可以运行,这里我把对象比作是一个小的程序。而多处理器,那么就另当别论了。
在这里我们首先学习一下公共方法wait,notify,notifyAll。
wait方法可以使在当前线程的对象等待,直到别的线程调用此对象的notify或notifyAll方法(注意:调用的是此对象的notify和notifyAll),并且当前运行的线程必须具有此对象的对象监视器,对象监视器我们可以从三个方法中获得,如下:
1.在执行对象实例同步方法体中,可以获得此对象的对象监视器,例子伪代码如下:
synchronized void aMethod(){
while(condition)
this.wait();
//other mothed;
}
2.通过执行对象同步synchronized正文,例子伪代码如下:
synchronized(this){
while(condition)
this.wait();
//other mothed;
}
3.对于 Class
类型的对象,可以通过执行该类的同步静态方法
这个方法可以使当前对象满足条件condition后,执行等待,当前线程对象放弃锁,cpu记录当前线程状态,以备下次回复。然后让其他线程运行,直到其他线程调用此对象的notify或notifyAll方法,此对象才会重新获得此对象的对象监视器,此对象才能重新运行。
注意:调用这个方法,必须具有对象监视器,也就是说我们必须在这三种方法选一种来获得对象监视器,如果调用此方法wait,却没用对象监视器,那么运行时会抛出IllegalMonitorStateException.
而且,在静态方法中也无法获得对象监视器,只能在Class类型的对象中,我们才可以通过调用该类的同步静态方法来获得对象监视器。
wait()
JDk文档写道
在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前,导致当前线程等待。换句话说,此方法的行为就好像它仅执行 wait(0) 调用一样。
当前线程必须拥有此对象监视器 。该线程发布对此监视器的所有权并等待,直到其他线程通过调用 notify 方法,或 notifyAll 方法通知在此对象的监视器上等待的线程醒来。然后该线程将等到重新获得对监视器的所有权后才能继续执行。
对于某一个参数的版本,实现中断和虚假唤醒是可能的,而且此方法应始终在循环中使用:
1
2
3
4
5
|
synchronized (obj) {
while (<condition does not hold>)
obj.wait();
...
}
|
此方法只应由作为此对象监视器的所有者的线程来调用。
对于红色部分的内容,个人曾一直都不是很理解,什么叫做拥有此对象的监视器。下面我们看看代码:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
DateFormat format = new SimpleDateFormat( "yyyy-MM-dd:hh:mm:ss" );
private String getTime(){
return format.format(Calendar.getInstance().getTime());
}
private Object monitor = new Object();
public void waitOnce(String thread, final long ms) {
Thread waitThread = new Thread() {
public void run() {
synchronized (monitor) {
try {
System.out.println( "Thread "
+ Thread.currentThread().getName()
+ " Wait at " + getTime());
monitor.wait(ms);
System.out.println( "Thread "
+ Thread.currentThread().getName()
+ " Waked at " + getTime());
} catch (InterruptedException e) {
}
}
};
};
waitThread.setName(thread);
waitThread.start();
}
|
如果我们去掉synchronized(monitor) ,运行则会出现异常IllegalMonitorStateException。
1
2
|
WaitAndNotifyTest test = new WaitAndNotifyTest();
test.waitOnce( "1" , Long.MAX_VALUE);
|
写道
Exception in thread “1″ java.lang.IllegalMonitorStateException
而加上以后就没问题了。因此个人觉得使用synchronized关键字锁定对象,也就是获得了对象的监视器了。
notify()
JDK文档 写道
唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待,则会选择唤醒其中一个线程 。选择是任意性 的,并在对实现做出决定时发生。线程通过调用其中一个 wait 方法,在对象的监视器上等待。
直到当前线程放弃此对象上的锁定,才能继续执行被唤醒的线程 。被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争;例如,唤醒的线程在作为锁定此对象的下一个线程方面没有可靠的特权或劣势。
此方法只应由作为此对象监视器的所有者的线程来调用。通过以下三种方法之一,线程可以成为此对象监视器的所有者:
通过执行此对象的同步实例方法。
通过执行在此对象上进行同步的 synchronized 语句的正文。
对于 Class 类型的对象,可以通过执行该类的同步静态方法。
一次只能有一个线程拥有对象的监视器。
抛出:
IllegalMonitorStateException – 如果当前线程不是此对象监视器的所有者。
首先理解一下获得对象的监视器,简单的说就是取得了当前对象的“加锁”使用权,最简单的就是使用synchronized关键字。另外使用 synchronized修饰的方法也行。
notify方法还有一个值得提出的是它会在当前线程释放了对象锁以后随机唤醒一个在该对象上等待的线程 。
看看一个例子:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
public void awakeAndWait(String thread, final long ms) {
Thread notifyThread = new Thread() {
public void run() {
synchronized (monitor) {
monitor.notify();
System.out.println( "Thread "
+ Thread.currentThread().getName() + " Notify at "
+ getTime());
try {
Thread.sleep(ms);
} catch (InterruptedException e) {
}
}
try {
Thread.sleep(ms);
} catch (InterruptedException e) {
}
};
};
notifyThread.setName(thread);
notifyThread.start();
}
|
这个方法会唤醒一个在对象上等待的线程,并在两次sleep后退出,注意的是一个sleep是在对象锁内,而另一次则是在释放了对象锁以后,这时候运行上面2个方法得到:
1
2
3
4
5
6
7
8
9
10
11
|
WaitAndNotifyTest test = new WaitAndNotifyTest();
test.waitOnce( "1" , Long.MAX_VALUE);
test.waitOnce( "2" , Long.MAX_VALUE);
test.waitOnce( "3" , Long.MAX_VALUE);
try {
Thread.sleep( 2000 );
} catch (InterruptedException e) {
}
test.awakeAndWait( "3" , 2000 );
|
执行结果为:
写道
Thread 1 Wait at 2011-05-06:10:57:04
Thread 2 Wait at 2011-05-06:10:57:04
Thread 3 Wait at 2011-05-06:10:57:04
Thread 3 Notify at 2011-05-06:10:57:06
Thread 1 Waked at 2011-05-06:10:57:08
2秒后唤醒了线程1,尽管它自己执行花了4s,在释放了对象锁之后的2s不会影响线程1的执行。
notifyAll()
JDK文档 写道
唤醒在此对象监视器上等待的所有线程 。线程通过调用其中一个 wait 方法,在对象的监视器上等待。
直到当前线程放弃此对象上的锁定,才能继续执行被唤醒的线程。被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争;例如,唤醒的线程在作为锁定此对象的下一个线程方面没有可靠的特权或劣势。
此方法只应由作为此对象监视器的所有者的线程来调用。有关线程能够成为监视器所有者的方法的描述,请参阅 notify 方法。
抛出:
IllegalMonitorStateException – 如果当前线程不是此对象监视器的所有者。
与notify稍微有一点差别的是,它会唤醒所有的等待线程。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
public void awakeAll(String thread) {
Thread notifyThread = new Thread() {
public void run() {
synchronized (monitor) {
monitor.notifyAll();
System.out.println( "Thread "
+ Thread.currentThread().getName()
+ " Notify all at " + getTime());
}
};
};
notifyThread.setName(thread);
notifyThread.start();
}
|
执行一下代码:
1
2
3
4
5
6
7
8
9
|
WaitAndNotifyTest test = new WaitAndNotifyTest();
test.waitOnce( "1" , Long.MAX_VALUE);
test.waitOnce( "2" , Long.MAX_VALUE);
test.waitOnce( "3" , Long.MAX_VALUE);
try {
Thread.sleep( 2000 );
} catch (InterruptedException e) {
}
test.awakeAll( "4" );
|
结果为:
写道
Thread 1 Wait at 2011-05-06:10:59:15
Thread 3 Wait at 2011-05-06:10:59:15
Thread 2 Wait at 2011-05-06:10:59:15
Thread 4 Notify all at 2011-05-06:10:59:17
Thread 2 Waked at 2011-05-06:10:59:17
Thread 3 Waked at 2011-05-06:10:59:17
Thread 1 Waked at 2011-05-06:10:59:17
全部唤醒了。
总结
总结一下:大概有以下几点:
- wait(),notify(),notifyAll()都需要在拥有对象监视器的前提下执行,否则会出现异常
IllegalMonitorStateException。
- 多个线程可以同时在一个对象上等待。
- notify()将随机唤醒一个在对象上等待的线程,没有一个都没有,则什么都不做。
- notify()唤醒的线程,将在notify()线程释放了对象监视器以后才执行,并不是notify了以后马上执行。
- Object的这些方法与Thread的sleep、interrupt相差还是很远的,不要混为一谈了。
分享到:
相关推荐
主要介绍了Java 中Object的wait() notify() notifyAll()方法使用的相关资料,需要的朋友可以参考下
创建多个condition对象 一个condition对象的signal(signalAll)方法和该对象的await方法是一一对应的,也就是一个condition对象的signal(signalAll)...Condition类的signalAll方法和Object类的notifyAll方法等效
1.这两个方法来自不同的类,sleep是Thread类的方法,而wait是Object类的方法; 2.执行sleep方法后不会释放锁,而执行wait方法后会释放锁; 3.wait,notify和notifyAll只能在同步方法或同步代码块中调用,而sleep可以...
为什么线程通信的方法wait(), notify()和notifyAll()被定义在Object 类里 遍历一个 List 有哪些不同的方式?每种方法的实现原理是什么 String str="i"与 String str=new String("i")一样吗 用过ConcurrentHashMap,...
wait是Object类的方法,对此对象调用wait方法导致本线程放弃对象锁,进入等待此对象的等待锁定池,只有针对此对象发出notify方法(或notifyAll)后本线程才进入对象锁定池准备获得对象锁进入运行状态。) sleep...
wait set——线程的休息室 wait方法——把线程放入wait set notify方法——从wait set拿出线程 notifyAll方法——从wait set拿出所有线程 wait、notify、notifyAll是Object类的方法 线程的状态移转 跟线程有关的其他...
wait是Object类的方法,对此对象调用wait方法导致本线程放弃对象锁,进入等待此对象的等待锁定池,只有针对此对象发出notify方法(或notifyAll)后本线程才进入对象锁定池准备获得对象锁进入运行状态。 62、同步和...
注意:上述方法只能被同步监听锁对象来调用,这也是为啥wait() 和 notify()方法都在 Object 对象中,因为同步监听锁可以是任意对象,只不过必须是需要同步线程的共同对象即可,否则别的对象调用会报错: java.lang...
只有当别的线程在该对象上调用了 notify()或者notifyAll()方法,"Wait Set"队列中的线程才得到机会去竞争,但是只有一个线程获得对象的Monitor,恢复到运行态。"Wait Set"中的线程在Thread Dump中显示的状态为 in ...
描述一下notify和notifyAll区别; synchronized关键字加在静态方法和实例方法的区别; 用锁的注意点; cas机制可能导致的问题ABA,什么是ABA; 程序开多少线程合适; 实现一下DCL(双重检查锁) stream 和 parallel...
16.4.9 防止错误的使用wait、notify、notifyAll方法 371 16.5 获取当前正在运行的线程 372 16.6 volatile关键字的含义与使用 372 16.7 小结 373 第17章 高级线程开发 374 17.1 线程池的使用 374 17.1.1...
LeetCode判断字符串是否循环 知识点总结 java基础 1、使用迭代器和for each循环查看集合元素时只能获得元素的值,不能改变元素 ...object的方法:wait(notify,notifyall),thread的方法:(sleep、join),结束
wait是Object类的方法,对此对象调用wait方法导致本线程放弃对象锁,进入等待此对象的等待锁定池,只有针对此对象发出notify方法(或notifyAll)后本线程才进入对象锁定池准备获得对象锁进入运行状态。 14、Overload...
wait是Object类的方法,对此对象调用wait方法导致本线程放弃对象锁,进入等待此对象的等待锁定池,只有针对此对象发出notify方法(或notifyAll)后本线程才进入对象锁定池准备获得对象锁进入运行状态。
Object类的方法(平安) clone() equals(object) finalize() getClass() hashCode() notify() notifyAll() toString() wait() String String、StringBuffer、StringBuilder三者的区别: 都在java.lang 包下 String使用...
Java自1995年面世以来得到了广泛得一个运用,但是对多...在Java 5.0之前Java里的多线程编程主要是通过Thread类,Runnable接口,Object对象中的wait()、 notify()、 notifyAll()等方法和synchronized关键词来实现的。
實踐53:優先使用notifyAll()而非notify() 185 實踐54:針對wait()和notifyAll()使用旋鎖(spin locks) 187 實踐55:使用wait()和notifyAll()替換輪詢循環(polling loops) 191 實踐56:不要對locked object(㆖鎖...
page对象就是指向当前JSP页面本身,有点象类中的this指针,它是java.lang.Object类的实例 序号 方 法 说 明 1 class getClass 返回此Object的类 2 int hashCode() 返回此Object的hash码 3 boolean equals...
wait是Object类的方法,对此对象调用wait方法导致本线程放弃对象锁,进入等待此对象的等待锁定池,只有针对此对象发出notify方法(或notifyAll)后本线程才进入对象锁定池准备获得对象锁进入运行状态。 17、...
wait是Object类的方法,对此对象调用wait方法导致本线程放弃对象锁,进入等待此对象的等待锁定池,只有针对此对象发出notify方法(或notifyAll)后本线程才进入对象锁定池准备获得对象锁进入运行状态。 14、...