This article mainly introduces the relevant information about the implementation of thread waiting and notification in Java. I hope this article can help everyone to master such functions. Friends in need can refer to it
Implementation of thread waiting and notification in java
Preface:
The key points to remember about waiting/notification are:
The wait(), notify(), and notifyAll() methods must be called from within the synchronization environment. A thread cannot call wait or notify methods on an object unless it owns a lock on that object.
wait(), notify(), notifyAll() are all instance methods of Object. Just like each object has a lock, each object can have a list of threads that wait for signals (notifications) from it. The thread obtains this waiting list by executing the wait() method on the object. From that point on, it does not execute any other instructions until the object's notify() method is called. If multiple threads are waiting on the same object, only one thread will be selected (in no guaranteed order) to continue execution. If no threads are waiting, no special action is taken.
Sample code:
package threadwait;
public class ThreadA extends Thread{
public int num = 0;
public void run(){
synchronized (this){//在此类对象上实现同步，this指代当前对象
for(int i = 0 ; i < 3 ; ++i)
this.num+=i;
notifyAll();//通知所有在这个对象上等待的线程开始执行，在这里就是通知TestNotify主线程开始执行
}
}
public int getNum(){
return this.num;
}
}package threadwait;
public class TestNotify{
public static void main(String args[]){
ThreadA threada = new ThreadA();
threada.start();//threada线程有执行的资格，但是还没有开始执行
synchronized(threada){
try{
threada.wait();//主线程等待threada线程执行结束才开始执行
//而且只有获得了当前threada对象的锁之后才能执行wait，就是说在同步域内才可以执行wait，执行wait后放弃对象锁
}catch(InterruptedException e){
e.printStackTrace();
}
}
System.out.println(threada.getNum());
}
}Synchronization can be at the class level, synchronized(A.class) , it can also be synchronized(this) at the object level, it can be a static synchronization method, static synchronized, the static synchronization method is at the class level, the non-static synchronization method is at the class object level, there is only one class object Lock, only when the lock is obtained can the wait operation be performed on it, and then the lock is released.
Further example code is as follows:
package threadwait;
public class ThreadA extends Thread{
public int num = 0;
public void run(){
synchronized (this){//在此类对象上实现同步，this指代当前对象
for(int i = 0 ; i < 3 ; ++i)
this.num+=i;
try{
Thread.sleep(500);//如果ThreadB的三个示例线程在还没有进入等待状态之前就受到了notifyall的信号
//那将会发生严重后果，因为调用notifyall的线程只可以调用一次notifyall，那造成等待的线程将永远等待下去
//所以在此处让它睡一小会，让其他线程有时间进入等待状态。
//不然会收到
}catch(InterruptedException e){
e.printStackTrace();
}
notifyAll();//通知所有在这个对象上等待的线程开始执行，在这里就是通知TestNotify主线程开始执行
}
// notifyAll();
}
public int getNum(){
return this.num;
}
}package threadwait;
public class ThreadB extends Thread{
private ThreadA threada;
public ThreadB(ThreadA ta){
this.threada = ta;
}
public void run(){
System.out.println(Thread.currentThread().getName()+" is waitting.");
synchronized(threada){
try{
threada.wait();
}catch(InterruptedException e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+" "+this.threada.getNum());
}
}
}package threadwait;
public class TestNotify{
public static void main(String args[]){
ThreadA threada = new ThreadA();
new ThreadB(threada).start();
new ThreadB(threada).start();
new ThreadB(threada).start();
threada.start();
}
}The above is the detailed content of How to implement thread waiting and notification in Java. For more information, please follow other related articles on the PHP Chinese website!