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

What is the use of LockSupport in Java concurrent programming? I believe many inexperienced people don't know what to do about it. Therefore, this paper summarizes the causes and solutions of the problem. Through this article, I hope you can solve this problem.

1. What is LockSupport?

LockSupport is the basic thread blocking primitive for creating locks and other synchronization classes

2. Two types of basic API

LockSupport provides two basic types of API:

Block thread class: usually a method name that begins with pack, pack* (...)

There are two overloaded versions of the pack method: blocker is an object that specifies which object to block. If you don't know, the this of the lock object is blocker by default.

Public static void park (); public static void park (Object blocker)

Extension: parkNanos function

Public static void parkNanos (Object blocker, long nanos) {if (nanos > 0) {/ / get the current thread Thread t = Thread.currentThread (); / / set Blocker setBlocker (t, blocker); / / obtain the license and set the time UNSAFE.park (false, nanos) / / set the license, reset blocker to null, avoid unpack, and obtain the blocker as setBlocker (t, null) previously set;}}

The nanos parameter indicates the relative time and how long to wait.

ParkUntil function: indicates that the current thread is disabled before the specified time limit, and the deadline parameter indicates the absolute time and the specified time

Public static void parkUntil (Object blocker, long deadline) {/ / get the current thread Thread t = Thread.currentThread (); / / set Blocker setBlocker (t, blocker); UNSAFE.park (true, deadline); / / set Blocker to null setBlocker (t, null);}

UnBlock thread class: unpack (Thread)

The unpack method is used to release the license, and the specified thread can continue to run.

3. The essence of LockSupport

LockSupport is a licensed semaphore mechanism, pack consumption, unpack into, put in is only one, does not accumulate. For example, call unpack to put a semaphore and call it multiple times. This semaphore will not accumulate, and it will be consumed after the pack call.

4. LockSupport example

Example: how to control two threads to print 1,2,3,4, 5, 6, …

Import java.util.concurrent.locks.LockSupport;public class LockSupportExample {private static final int total = 10; private static int i = 0; static Thread T1, T2; public static void main (String [] args) {T1 = new Thread (()-> {while (I)

< total) { System.out.println("t1:" + (++i)); LockSupport.unpark(t2); LockSupport.park(); } }); t2 = new Thread(() ->

{while (I < total) {LockSupport.park (); System.out.println ("T2:" + (+ + I)); LockSupport.unpark (T1);}}); t1.start (); t2.start ();}}

Print:

T1: 1

T2: 2

T1:3

T2:4

T1:5

T2:6

T1:7

T2:8

T1:9

T2:10

5. LockSupport source code public class LockSupport {/ / Hotspot implementation via intrinsics API private static final sun.misc.Unsafe UNSAFE; private static final long parkBlockerOffset; private static final long SEED; private static final long PROBE; private static final long SECONDARY; static {try {/ / get Unsafe instance UNSAFE = sun.misc.Unsafe.getUnsafe (); / / class object Class tk = Thread.class of thread class / / get the memory offset address of the parkBlocker field of Thread parkBlockerOffset = UNSAFE.objectFieldOffset (tk.getDeclaredField ("parkBlocker")); / / get the memory offset address of the threadLocalRandomSeed field of Thread SEED = UNSAFE.objectFieldOffset (tk.getDeclaredField ("threadLocalRandomSeed")) / / get the memory offset address of Thread's threadLocalRandomProbe field PROBE = UNSAFE.objectFieldOffset (tk.getDeclaredField ("threadLocalRandomProbe")); / / get the memory offset address of Thread's threadLocalRandomSecondarySeed field SECONDARY = UNSAFE.objectFieldOffset (tk.getDeclaredField ("threadLocalRandomSecondarySeed"));} catch (Exception ex) {throw new Error (ex);}

The source code of the pack method:

Public static void park (Object blocker) {/ / get the current thread Thread t = Thread.currentThread (); / / set Blocker setBlocker (t, blocker); / / get the license UNSAFE.park (false, 0L); / / set Blocker to null again to prevent unpack from getting the last set setBlocker (t, blocker); setBlocker (t, null);}

Source code of unpack:

Public static void unpark (Thread thread) {if (thread! = null) / / Thread is not empty UNSAFE.unpark (thread); / / release the thread license}

As you can see, both the source code of pack and the source code of unpack are implemented through the underlying api of Unsafe

Sun.misc.Unsafe tool classes that can directly perform underlying non-secure operations

The main operations are as follows:

Thread suspension and recovery

CAS operation

Manipulate object properti

Manipulate array elements

Direct manipulation of memory

After reading the above, have you mastered the use of LockSupport in Java concurrent programming? If you want to learn more skills or want to know more about it, you are welcome to follow the industry information channel, thank you for reading!

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.