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

This article mainly explains the "java thread waking up mechanism". The content of the article is simple and clear, and it is easy to learn and understand. let's go deep into the editor's train of thought. Let's study and learn the java thread waking up mechanism.

1) three ways to make threads wait and wake up

Method 1: use the wait () method in Object to make the thread wait, and use the notify () method in Object to wake up the thread

1. The wait () and notify/notifyAll () methods are local final methods of Object and cannot be overridden.

2. Wait () blocks the current thread on the premise that the lock must be obtained first, which is generally used with the synchronized keyword, that is, the wait () and notify/notifyAll () methods are generally used in the synchronized synchronization code block.

3. Since wait () and notify/notifyAll () are executed in the synchronized code block, it means that the current thread must have acquired the lock.

When the thread executes the wait () method, it releases the current lock, then gives up the CPU and goes into a waiting state.

It is only when notify/notifyAll () is executed that one or more waiting threads are awakened and then continue to execute until the code of the synchronized block is executed or wait () is encountered halfway, releasing the lock again.

In other words, the execution of notify/notifyAll () only wakes up the sleeping thread and does not immediately release the lock, which depends on the execution of the code block. So in programming, try to exit the critical area immediately after using notify/notifyAll () to wake up other threads to get the lock.

4. Wait () needs to be surrounded by try catch, so that an abnormal interrupt can also wake up the thread waiting by wait.

5. The order of notify and wait cannot be wrong. If thread An executes the notify method first and thread B is executing the wait method, then thread B cannot be awakened.

6. The difference between notify and notifyAll

The notify method wakes up only one waiting thread (of the object) and causes that thread to start execution. So if there are multiple threads waiting for an object, this method will wake up only one of them, and which thread to choose depends on the operating system's implementation of multithreaded management. NotifyAll wakes up all waiting threads, although which thread will handle it first depends on the implementation of the operating system. If there are multiple threads that need to be woken up in the current situation, the notifyAll method is recommended. For example, in the use of producer-consumer, all consumers or producers need to be awakened each time to determine whether the program can continue to execute.

7. To test the change of a condition in multithreading, use if or while?

Note that after notify wakes up the sleeping thread, the thread continues with the last execution. Therefore, when judging the condition, you can first ignore the wait statement to consider; obviously, to ensure that the program must be executed, and to ensure that the program is not executed until certain conditions are met, and use while to wait until the conditions are met before continuing to execute

Package com.lyy.juc;import java.util.concurrent.TimeUnit;public class LockSupportDemo {public static void main (String [] args) / / main method, all program entries of the main thread {Object objectLock = new Object (); / / the same lock, similar to resource class new Thread (()-> {synchronized (objectLock) {try {objectLock.wait ();} catch (InterruptedException e) {e.printStackTrace ()) }} System.out.println (Thread.currentThread (). GetName () + "\ t" + "awakened");}, "T1"). Start (); / / pauses thread try {TimeUnit.SECONDS.sleep (3L) for a few seconds;} catch (InterruptedException e) {e.printStackTrace () } new Thread (()-> {synchronized (objectLock) {objectLock.notify ();} / / objectLock.notify (); / * synchronized (objectLock) {try {objectLock.wait ();} catch (InterruptedException e) {e.printStackTrace () } * /}, "T2") .start ();}}

Print in three seconds

T1 was awakened.

Method 2: use the await () method of Condition in the JUC package to make the thread wait, and use the signal () method to wake up the thread

Package com.lyy.juc;import java.util.concurrent.TimeUnit;import java.util.concurrent.locks.Condition;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;public class LockSupportDemo2 {public static void main (String [] args) {Lock lock = new ReentrantLock (); Condition condition = lock.newCondition (); new Thread (()-> {lock.lock (); try {System.out.println (Thread.currentThread (). GetName () + "\ t" + "start"); condition.await () System.out.println (Thread.currentThread (). GetName () + "\ t" + "awakened");} catch (InterruptedException e) {e.printStackTrace ();} finally {lock.unlock ();}}, "T1") .start (); / / pause thread try {TimeUnit.SECONDS.sleep (3L) for a few seconds } catch (InterruptedException e) {e.printStackTrace ();} new Thread (()-> {lock.lock (); try {condition.signal ();} catch (Exception e) {e.printStackTrace ();} finally {lock.unlock ();} System.out.println (Thread.currentThread (). GetName () + "\ t" + "notified")) }, "T2") .start ();}}

The T1 thread first executes start, then main executes sleep for three seconds, T2 executes start, first executes the await method, and then executes signal, so first printing T1 is awakened, T2 is notified later.

But if I change the order, the order of the printed results will be different.

Package com.lyy.juc;import java.util.concurrent.TimeUnit;import java.util.concurrent.locks.Condition;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;public class LockSupportDemo2 {public static void main (String [] args) {Lock lock = new ReentrantLock (); Condition condition = lock.newCondition (); / / pause a thread for several seconds try {TimeUnit.SECONDS.sleep (3L);} catch (InterruptedException e) {e.printStackTrace () } new Thread (()-> {lock.lock (); try {System.out.println (Thread.currentThread (). GetName () + "\ t" + "start"); condition.await (); System.out.println (Thread.currentThread (). GetName () + "\ t" + "Wake up");} catch (InterruptedException e) {e.printStackTrace ();} finally {lock.unlock () }, "T1"). Start (); new Thread (()-> {lock.lock (); try {System.out.println (Thread.currentThread (). GetName () + "\ t" + "start"); condition.signal ();} catch (Exception e) {e.printStackTrace ();} finally {lock.unlock () } System.out.println (Thread.currentThread (). GetName () + "\ t" + "notified");}, "T2") .start ();}}

Restrictions on the use of Object and Condition

To acquire and hold the lock, the thread must be in the lock block (synchronized or lock)

The mode 3:LockSupport class can block the current thread of park and wake up unpark to specify the blocked thread

Blocking and waking up threads are implemented through park () and unpark (thread) methods

LockSupport is the basic thread blocking primitive used to create locks and other synchronization classes.

The LockSupport class uses a concept called Permit to block and wake up threads, and each thread has a permit.

Permit has only two values of 1 and zero, and the default is zero.

You can think of a license as a semaphore (Semaphore), but unlike Semaphore, the cumulative upper limit of a license is 1.

Park () / park (Object blocker)

No pass blocking current thread / pass blocking incoming specific thread

Unpark (Thread thread) must specify the thread to wake up

Package com.lyy.juc;import java.util.concurrent.TimeUnit;import java.util.concurrent.locks.LockSupport;public class LockSupportDemo3 {public static void main (String [] args) {/ / normal use + no lock block Thread T1 = new Thread (()-> {System.out.println (Thread.currentThread (). GetName () + "+" 1111111111111 "); LockSupport.park () System.out.println (Thread.currentThread (). GetName () + "" + "2222222222222-end awakened");}, "T1"); t1.start (); / / pause threads for several seconds try {TimeUnit.SECONDS.sleep (3);} catch (InterruptedException e) {e.printStackTrace ();} LockSupport.unpark (T1) System.out.println (Thread.currentThread (). GetName () + "- LockSupport.unparrk () invoked over");}}

Permit defaults to zero, so as soon as the park () method is called, the current thread blocks until another thread sets the current thread's permit to 1, and the park method is awakened.

The permit is then set to zero again and returned.

When the unpark (thread) method is called, the thread thread's permission permit is set to 1 (note that multiple calls to the unpark method will not add up, and the Permit value is still 1) will automatically wake up the thread, that is, the LockSupport.park () method in the previous blocking will return immediately.

Thank you for your reading. the above is the content of "java thread waking up mechanism". After the study of this article, I believe you have a deeper understanding of the java thread waiting wake-up mechanism. the specific usage still needs to be verified in practice. Here is, the editor will push for you more related knowledge points of the article, welcome to follow!

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.