Shulou(Shulou.com)06/02 Report--

This article will explain in detail the usage of sleep/wait/notify/notifyAll in JAVA, and the content of the article is of high quality, so the editor will share it with you for reference. I hope you will have a certain understanding of the relevant knowledge after reading this article.

Brief introduction

First of all, give a brief explanation of several related methods. There are several methods for thread synchronization in Object: wait, notify, notifyAll.

Public class Object {public final native void wait (long timeout) throws InterruptedException; public final native void notify (); public final native void notifyAll ();}

Wait: releases the current lock and blocks until awakened by notify or notifyAll, or times out, or thread is interrupted (InterruptedException)

Notify: whichever thread is waiting on this object (cannot be controlled) wakes it up. Other threads are still waiting to be woken up.

NotifyAll: wake up all threads to compete, but only one can grab the lock

Sleep: not a method in Object, but a static method of the Thread class that lets the current thread hold the lock for a specified period of time

Sleep and wait

Both sleep and wait can block threads, specify a timeout, and even throw an interrupt exception InterruptedException.

The biggest difference between them is that when sleep, the thread still holds the lock, and others cannot enter the current synchronization method; when wait, the lock is abandoned, and other threads have a chance to enter the synchronization method. The synchronization method has been mentioned many times, because the wait must be in the synchronized synchronization code block, or it will throw an exception IllegalMonitorStateException,notify. It can be said that wait and notify are created for thread scheduling in synchronization code.

Here is a simple example to show the difference between sleep and wait:

Import java.util.Date;import java.util.concurrent.atomic.AtomicInteger;public class Main {/ / log line number records private AtomicInteger count = new AtomicInteger (); public static void main (String [] args) throws InterruptedException {Main main = new Main (); / / start two threads to execute the test method new Thread (main::test). Start (); new Thread (main::test). Start () } private synchronized void test () {try {log ("entered the synchronization method and started to sleep, 1s"); / / sleep will not release the lock, so other threads cannot enter this method Thread.sleep (1000); log ("sleep well, but have nothing to do, call me and wait for 2s") / / blocking here and releasing the lock, other threads can enter this method / / other threads have a chance to stop blocking when other threads call this object's notify or notifyAll / / even if no one notify, it will stop blocking wait (2000) if it times out; log ("I'm going to go, but I'm going to sleep again, 10s") / / slept here for a long time, because the lock was not released, and other threads could not continue to execute Thread.sleep (10000) even if wait timed out; log ("gone"); notify ();} catch (InterruptedException e) {e.printStackTrace () }} / / print log private void log (String s) {System.out.println (count.incrementAndGet () + "+ new Date (). ToString (). Split (") [3] + "\ t" + Thread.currentThread (). GetName () + "+ s)) }} / * output: 1 00:13:23 Thread-0 entered the synchronization method and began to sleep, 1s2 00:13:24 Thread-0 slept well, but nothing to do, something to call me, wait for 2s3 00:13:24 Thread-1 entered the synchronization method, and began to sleep, 1s4 00:13:25 Thread-1 sleep, but nothing to do, call me, wait for 2s5 00:13:26 Thread-0 I have to go, but I want to sleep again 10s6 00:13:36 Thread-0 left 7 00:13:36 Thread-1 I have to go, but I want to sleep again, 10s8 00:13:46 Thread-1 left * /

Give a simple explanation of the output (children's shoes that already understand the code can be skipped):

1 00:13:23 Thread-0 entered the synchronization method and began to sleep, 1s / / Thread-0 first entered the synchronization method, Thread-1 can only wait outside the door at 2 00:13:24 Thread-0 slept well, but nothing to do, something to call me, wait for 2s / / Thread-0 sleep 1 second, Thread-1 did not come in, proved that sleep did not release the lock 3 00:13:24 Thread-1 entered the synchronization method, and began to sleep 1s / / Thread-1 came in immediately after 1s / Thread-0 started wait, proving that wait released the lock 4 00:13:25 Thread-1 slept well, but nothing to do, something to call me, waiting for 2s / / Thread-1 is also going to wait 2 seconds (can I really wake up in 2 seconds? ) 5 00:13:26 Thread-0 I have to go, but I want to sleep again, 10s / / Thread-0 has wait overtime woke up, this preparation sleep 10s6 00:13:36 Thread-0 left / / 10s passed Thread-0 sleep is over, the Thread-1 that said wait 2s hasn't moved yet, it's no use proving timeout, I still have to grab lock 7 00:13:36 Thread-1 I have to go But I need to sleep again. After 10s / / Thread-0 exited the synchronization code, Thread-1 finally got the lock and was able to move. At 00:13:46 Thread-1 left notify and notifyAll.

It is also the same to wake up waiting threads, and at most one thread can acquire the lock, nor can it control which thread acquires the lock.

The difference is:

Notify: wakes up a thread, and the other thread is still in the wake-up state of wait. If the awakened thread ends without calling notify, the other thread will never be woken up and can only wait for a timeout or be interrupted.

NotifyAll: all threads exit the state of wait and begin to compete for locks, but only one thread can grab it. After this thread finishes execution, another lucky thread will stand out and get the lock.

If you feel that the explanation is not clear enough, let's have a wave of code:

Import java.util.Date;import java.util.concurrent.ArrayBlockingQueue;import java.util.concurrent.atomic.AtomicInteger;public class Main {private AtomicInteger count = new AtomicInteger (); public static void main (String [] args) throws InterruptedException {Main main = new Main (); / / start two threads to execute the test method for (int I = 0; I < 10; iSuppli +) {new Thread (main::testWait). Start () } Thread.sleep (1000); for (int I = 0; I < 5; iTunes +) {main.testNotify ();}} private synchronized void testWait () {try {log ("enter the synchronization method, start wait"); wait (); log ("wait end") } catch (InterruptedException e) {e.printStackTrace ();}} private synchronized void testNotify () {notify () } private void log (String s) {System.out.println (count.incrementAndGet () + "+ new Date (). ToString (). Split (") [3] + "\ t" + Thread.currentThread (). GetName () + "" + s) }} / * output: 1 00:59:32 Thread-0 entered synchronization method, started wait2 00:59:32 Thread-9 entered synchronization method, started wait3 00:59:32 Thread-8 entered synchronization method, started wait4 00:59:32 Thread-7 entered synchronization method, started wait5 00:59:32 Thread-6 entered synchronization method, started wait6 00:59:32 Thread-5 entered synchronization method Start wait7 00:59:32 Thread-4 enter synchronization method, start wait8 00:59:32 Thread-3 enter synchronization method, start wait9 00:59:32 Thread-2 enter synchronization method, start wait10 00:59:32 Thread-1 enter synchronization method Start wait11 00:59:33 Thread-0 wait end 12 00:59:33 Thread-6 wait end 13 00:59:33 Thread-7 wait end 14 00:59:33 Thread-8 wait end 15 00:59:33 Thread-9 wait end * /

In the example, there are 10 threads in wait, but notify 5 times, and then other threads keep blocking, which means that if you do not accurately control the number of threads in wait when using notify, it may cause some threads to block forever.

Use notifyAll to wake up all waiting threads:

Import java.util.Date;import java.util.concurrent.ArrayBlockingQueue;import java.util.concurrent.atomic.AtomicInteger;public class Main {private AtomicInteger count = new AtomicInteger (); public static void main (String [] args) throws InterruptedException {Main main = new Main (); / / start two threads to execute the test method for (int I = 0; I < 5; iSuppli +) {new Thread (main::testWait). Start () } Thread.sleep (1000); main.testNotifyAll ();} private synchronized void testWait () {try {log ("enter synchronization method, start wait"); wait (); log ("wait end");} catch (InterruptedException e) {e.printStackTrace () }} private synchronized void testNotifyAll () {notifyAll ();} private void log (String s) {System.out.println (count.incrementAndGet () + "+ new Date (). ToString (). Split (") [3] + "\ t" + Thread.currentThread (). GetName () + "" + s) }} / * output: 1 01:03:24 Thread-0 entered the synchronization method, wait2 01:03:24 Thread-4 entered the synchronization method, wait3 01:03:24 Thread-3 entered the synchronization method, wait4 01:03:24 Thread-2 entered the synchronization method, wait5 01:03:24 Thread-1 entered the synchronization method Start wait6 01:03:25 Thread-1 wait end 7 01:03:25 Thread-2 wait end 8 01:03:25 Thread-3 wait end 9 01:03:25 Thread-4 wait end 10 01:03:25 Thread-0 wait end * /

You only need to call notifyAll once, and all waiting threads are awakened, compete for locks, and then acquire locks in turn (out of order) to complete subsequent tasks.

Why should wait be used in a loop

When wait appears in some source code, it is often accompanied by a circular statement, such as:

Private synchronized void f () throws InterruptedException {while (! isOk ()) {wait ();} System.out.println ("Ihumm ok");}

Since wait will be blocked until it is woken up, wouldn't it be fine to use if+wait? Why not just notify when other threads find that the condition is met?

Ideally, this is true, but in actual development, we often cannot guarantee that the condition has been met when the thread is notify, because it is likely that some unrelated thread (which has nothing to do with the logic of the condition) has called notify or notifyAll because it needs thread scheduling. At this point, if the thread waiting at the location in the sample happens to be awakened, it will continue to execute, but because of the if used, the awakening will no longer determine whether the condition is met, and the program will eventually execute in the way we do not expect.

What about the use of sleep/wait/notify/notifyAll of JAVA to share here, I hope the above content can be of some help to you, can learn more knowledge. If you think the article is good, you can share it for more people to see.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.