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

This article mainly introduces the relevant knowledge of "how to use the atomic Atomic of Java". The editor shows you the operation process through an actual case. The operation method is simple, fast and practical. I hope this article "how to use the atomic Atomic of Java" can help you solve the problem.

Thread safety

When multiple threads access a class, regardless of how the runtime environment is scheduled or how these processes will be executed alternately, and without any additional synchronization or coordination in the tone code, the class behaves correctly, so call this class thread-safe.

Thread safety is mainly reflected in the following three aspects

Atomicity: provides mutually exclusive access, which can only be operated on by one thread at a time

Visibility: changes made by one thread to main memory can be observed by other threads in time

Orderability: one thread observes the order of instruction execution in other threads, which is generally disordered due to the reordering of instructions

Detailed explanation of Atomic package in JUC

Many classes of Atomicxxx are provided in the Atomic package:

They are all CAS (compareAndSwap) to achieve atomicity.

Let's write a simple example as follows:

@ Slf4jpublic class AtomicExample1 {/ / Total number of requests public static int clientTotal = 5000; / / number of threads executing concurrently public static int threadTotal = 200; public static AtomicInteger count = new AtomicInteger (0); public static void main (String [] args) throws Exception {ExecutorService executorService = Executors.newCachedThreadPool (); final Semaphore semaphore = new Semaphore (threadTotal); final CountDownLatch countDownLatch = new CountDownLatch (clientTotal); for (int I = 0; I

{try {semaphore.acquire (); add (); semaphore.release ();} catch (Exception e) {log.error ("exception", e);} countDownLatch.countDown ();}) } countDownLatch.await (); executorService.shutdown (); log.info ("count: {}", count.get ());} private static void add () {count.incrementAndGet ();}}

We can send out the result of each run is always 5000 of the expected result we want. It shows that the counting method is thread-safe.

Let's take a look at the count.incrementAndGet () method. Its first parameter is the object itself, and the second parameter is valueOffset, which is used to record the compilation address of the value itself in memory. This record is mainly to find the location of the value in memory in the update operation for easy comparison. The third parameter is the constant 1.

Public class AtomicInteger extends Number implements java.io.Serializable {private static final long serialVersionUID = 6214790243416807050L; / / setup to use Unsafe.compareAndSwapInt for updates private static final Unsafe unsafe = Unsafe.getUnsafe (); private static final long valueOffset; static {try {valueOffset = unsafe.objectFieldOffset (AtomicInteger.class.getDeclaredField ("value"));} catch (Exception ex) {throw new Error (ex);}} private volatile int value ... Several methods are omitted here. / Atomically increments by one the current value. * * @ return the updated value * / public final int incrementAndGet () {return unsafe.getAndAddInt (this, valueOffset, 1) + 1;}}

A Unsafe class is used in the AtomicInteger source code, which provides a method of getAndAddInt. Let's go on to see its source code:

Public final class Unsafe {private static final Unsafe theUnsafe;.... Many methods and member variables are omitted here. Public final int getAndAddInt (Object var1, long var2, int var4) {int var5; do {var5 = this.getIntVolatile (var1, var2);} while (! this.compareAndSwapInt (var1, var2, var5, var5 + var4)); return var5;} public final native boolean compareAndSwapInt (Object var1, long var2, int var4, int var5); public native int getIntVolatile (Object var1, long var2);}

You can see that a do while statement is used to do the body implementation. The core of the while statement is to call a method of compareAndSwapInt (). It is a native method, it is an underlying method, and is not implemented using Java.

Suppose we want to perform the operation of 0: 1: 0, here are the values of each parameter in the case of a single thread:

After update:

The first parameter (var1) of the compareAndSwapInt () method is the current object, which is count in the code example. At this point, its value is 0 (expected). The second value (var2) is the passed valueOffset value, which has a value of 12. The third parameter (var4) is the constant 1. The variable parameter (var5) in the method is the value obtained by calling the underlying getIntVolatile method based on parameter 1 and parameter 2 valueOffset, where its value is 0. What compareAndSwapInt () wants to achieve is for the object count, if the value in the current expected value var1 is the same as the underlying returned value (var5), then update it to the value var5+var4. If different, recycle the expected value (var5) until the current value is the same as the expected value. The core of the compareAndSwap method is what we usually call CAS.

The implementation principle of other classes under the Atomic package, such as AtomicLong, is basically the same as above.

Let's introduce the LongAdder class again, and from the above analysis, we already know that AtomicLong uses CAS: constantly trying to change the target value in an endless loop until the change is successful. If the competition is not fierce, the probability of successful modification is very high. On the other hand, if in the case of fierce competition, the probability of failure of the modification will be high, it will make many loop attempts, so the performance will be affected.

For normal types of long and double variables, jvm allows 64-bit read or write operations to be split into two 32-bit operations. The core idea of LongAdder is to separate the hot spot data. It can separate the core data value of AtomicLong into an array, and when each thread accesses, it maps to one of the numbers through hash and other algorithms to count. The final count result is the summation of the array, in which the hot spot data value, which will be separated into multiple units of cell, each cell maintains internal values independently, and the actual value of the current object is accumulated by all cell. In this way, the hot spots are separated effectively and the parallelism is improved. LongAdder is equivalent to dispersing the pressure of a single point of update to each node on the basis of AtomicLong. In the case of low concurrency, the direct update of base can ensure that the performance of Atomic is basically the same. In the case of high concurrency, performance is improved through dispersion. However, if there are concurrent updates in the statistics, it may lead to errors in the statistical data.

When the concurrency count is actually high, LongAdder can be used first. AtomicLong can be preferred when parallelism is low or exact values are needed, which is more efficient.

The following is a simple demonstration of the simple use of AtomicReference under the Atomic package:

@ Slf4jpublic class AtomicExample4 {private static AtomicReference count = new AtomicReference (0); public static void main (String [] args) {count.compareAndSet (0,2); count.compareAndSet (0,1); log.info ("count: {}", count.get ());}}

CompareAndSet () passes in the expected value and the updated value respectively, and updates the value to the updated value only if the expected value is equal to the current value.

The first method above updates the value to 2, while the second step cannot update the value to 1.

Here's a brief introduction to the use of AtomicIntegerFieldUpdater (to update an instance of a class using atomicity):

@ Slf4jpublic class AtomicExample5 {private static AtomicIntegerFieldUpdater updater = AtomicIntegerFieldUpdater.newUpdater (AtomicExample5.class, "count"); @ Getter private volatile int count = 100; public static void main (String [] args) {AtomicExample5 example5 = new AtomicExample5 (); if (updater.compareAndSet (example5, 100120)) {log.info ("update success 1, {}", example5.getCount ()) } if (updater.compareAndSet (example5, 100,120)) {log.info ("update success 2, {}", example5.getCount ());} else {log.info ("update failed, {}", example5.getCount ());}

It can update the value of a specified member variable in a class.

Note: modified member variables need to be decorated with the volatile keyword and cannot be fields described by static.

The core of AtomicStampReference class is to solve the ABA problem of CAS (during the CAS operation, other threads change the value of the variable A to B, and then change it back to A. when the thread uses the expected value A to compare the current variable with the current variable, it finds that the A variable has not changed, so CAS swaps the A value.

This value has actually been changed by other threads.

The solution to the ABA problem is to add the version number to one every time the variable changes.

Take a look at one of its core methods compareAndSet ():

Public class AtomicStampedReference {private static class Pair {final T reference; final int st private Pair (T reference, int stamp) {this.reference = reference; this.stamp = st} static Pair of (T reference, int stamp) {return new Pair (reference, stamp);}}. Several methods are omitted here. Public boolean compareAndSet (V expectedReference, V newReference, int expectedStamp, int newStamp) {Pair current = pair Return expectedReference = = current.reference & & expectedStamp = = current.stamp & & ((newReference = = current.reference & & newStamp = = current.stamp) | | casPair (current, Pair.of (newReference, newStamp));}}

You can see that it has an extra stamp comparison, and the value of stamp is maintained each time it is updated.

Let's introduce AtomicLongArray, which maintains an array. Under this array, we can selectively update the corresponding value of an index.

Public class AtomicLongArray implements java.io.Serializable {private static final long serialVersionUID =-2308431214976778248L; private static final Unsafe unsafe = Unsafe.getUnsafe (); Omit here. / * * Atomically sets the element at position {@ code I} to the given value * and returns the old value. * * @ param i the index * @ param newValue the new value * @ return the previous value * / public final long getAndSet (int I, long newValue) {return unsafe.getAndSetLong (array, checkedByteOffset (I), newValue);} / * * Atomically sets the element at position {@ code I} to the given * updated value if the current value {@ code = =} the expected value. * * @ param i the index * @ param expect the expected value * @ param update the new value * @ return {@ code true} if successful. False return indicates that * the actual value was not equal to the expected value. * / public final boolean compareAndSet (int I, long expect, long update) {return compareAndSetRaw (checkedByteOffset (I), expect, update);}

Finally, write a simple use of AtomcBoolean:

@ Slf4jpublic class AtomicExample6 {private static AtomicBoolean isHappened = new AtomicBoolean (false); / / Total number of requests public static int clientTotal = 5000; / / number of concurrent execution threads public static int threadTotal = 200; public static void main (String [] args) throws Exception {ExecutorService executorService = Executors.newCachedThreadPool (); final Semaphore semaphore = new Semaphore (threadTotal); final CountDownLatch countDownLatch = new CountDownLatch (clientTotal); for (int I = 0; I

{try {semaphore.acquire (); test (); semaphore.release ();} catch (Exception e) {log.error ("exception", e);} countDownLatch.countDown ();}) } countDownLatch.await (); executorService.shutdown (); log.info ("isHappened: {}", isHappened.get ());} private static void test () {if (isHappened.compareAndSet (false, true)) {log.info ("execute") This is the end of the introduction to "how to use the atomic Atomic of Java". Thank you for reading. If you want to know more about the industry, you can follow the industry information channel. The editor will update different knowledge points for you every day.

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.