Detailed introduction to code sharing used by the Atomic package in Java

Introduction

Java has provided the java.util.concurrent.atomic package since JDK1.5 to facilitate programmers to perform lock-free atomic operations in a multi-threaded environment. The bottom layer of atomic variable uses the atomic instructions provided by the processor, but different CPU architecture may provide different atomic instructions, and may also require some form of internal lock, so this The method cannot absolutely guarantee that the thread will not be blocked.

Atomic package introduction

There are 12 classes in the Atomic package, and four atomic update methods, namely atomic update basic type, atomic update array, atomic update reference and atomic update field. The classes in the Atomic package are basically wrapper classes implemented using Unsafe.

Atomic update basic type class

is used to update basic types atomically. The Atomic package provides the following three classes:

• AtomicBoolean: Atomic updateBoolean type.

• AtomicInteger: Atomic update integer.

• AtomicLong: Atomic update long.

The common methods of AtomicInteger are as follows:

• int addAndGet(int delta): atomically combine the input value with the value in the instance ( value in AtomicInteger) is added and the result is returned

• boolean compareAndSet(int expect, int update): If the input value is equal to the expected value, the value is atomically set to The value entered.

• int getAndIncrement(): Atomically add 1 to the current value. Note: The value returned here is the value before the increment.

• void lazySet(int newValue): It will eventually be set to newValue. After using lazySet to set the value, other threads may still be able to read the old value in a short period of time.

• int getAndSet(int newValue): Atomically sets the value to newValue and returns the old value.

AtomicInteger example code is as follows:

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicIntegerTest {

	static AtomicInteger ai = new AtomicInteger(1);

	public static void main(String[] args) {
		System.out.println(ai.getAndIncrement());
		System.out.println(ai.get());
	}

}

Output

1
2

Dessert

The Atomic package provides three basic types of Atomic update, but Java’s basic types include char, float, double, etc. So the question is, how to update other basic types atomically? The classes in the Atomic package are basically implemented using Unsafe. Let's take a look at the source code of Unsafe and find that Unsafe only provides three CAS methods, compareAndSwapObject, compareAndSwapInt and compareAndSwapLong. Looking at the AtomicBoolean source code, we find that it first converts Boolean into an integer, and then use compareAndSwapInt to perform CAS, so atomic update of double can also be implemented using a similar idea.

Atomic update array class

Update an element in the array atomically. The Atomic package provides the following three classes:

• AtomicIntegerArray : Atomic update of elements in an integer array.

• AtomicLongArray: Atomic update of elements in a long integer array.

• AtomicReferenceArray: Atomic update of elements in a reference type array.

The AtomicIntegerArray class mainly provides an atomic way to update the integer in the array. Its common methods are as follows

• int addAndGet(int i, int delta): Atomically adds the input value to the element at index i in the array.

• boolean compareAndSet(int i, int expect, int update): If the current value is equal to the expected value, atomically set the element at array position i to the update value.

The example code is as follows:

public class AtomicIntegerArrayTest {

	static int[] value = new int[] { 1, 2 };

	static AtomicIntegerArray ai = new AtomicIntegerArray(value);

	public static void main(String[] args) {
		ai.getAndSet(0, 3);
		System.out.println(ai.get(0));
                System.out.println(value[0]);
	}

}

Output

3
1

AtomicIntegerArray class It should be noted that the array value is passed through the constructor method Go in, and then AtomicIntegerArray will make a copy of the current array, so when AtomicIntegerArray modifies the internal array elements, it will not affect the incoming array.

Atomic update reference type

Atomic update of the basic type AtomicInteger can only update one variable. If you want to update multiple variables atomically, you need to use the class provided by this atomic update reference type. The Atomic package provides the following three classes:

• AtomicReference: Atomic update reference type.

• AtomicReferenceFieldUpdater: Atomic update of fields in reference types.

• AtomicMarkableReference: Atomic update of a reference type with a mark bit. It is possible to atomically update a boolean flag bit and reference type. The construction method is AtomicMarkableReference(V initialRef, boolean initialMark)

The example code for using AtomicReference is as follows:

public class AtomicReferenceTest {

	public static AtomicReference<user> atomicUserRef = new AtomicReference</user><user>();

	public static void main(String[] args) {
		User user = new User("conan", 15);
		atomicUserRef.set(user);
		User updateUser = new User("Shinichi", 17);
		atomicUserRef.compareAndSet(user, updateUser);
		System.out.println(atomicUserRef.get().getName());
		System.out.println(atomicUserRef.get().getOld());
	}

	static class User {
		private String name;
		private int old;

		public User(String name, int old) {
			this.name = name;
			this.old = old;
		}

		public String getName() {
			return name;
		}

		public int getOld() {
			return old;
		}
	}
}

Output

Shinichi
17

Atomic update field class

If we only need a certain field in a certain class, then we need to use atomic update field class. The Atomic package provides the following three classes:

• AtomicIntegerFieldUpdater: Updater for atomically updating integer fields.

• AtomicLongFieldUpdater: Updater for atomically updating long integer fields.

• AtomicStampedReference：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于原子的更数据和数据的版本号，可以解决使用CAS进行原子更新时，可能出现的ABA问题。

原子更新字段类都是抽象类，每次使用都时候必须使用静态方法newUpdater创建一个更新器。原子更新类的字段的必须使用public Volatile修饰符。AtomicIntegerFieldUpdater的例子代码如下：

public class AtomicIntegerFieldUpdaterTest {

	private static AtomicIntegerFieldUpdater<User> a = AtomicIntegerFieldUpdater
			.newUpdater(User.class, "old");

	public static void main(String[] args) {
		User conan = new User("conan", 10);
		System.out.println(a.getAndIncrement(conan));
		System.out.println(a.get(conan));
	}

	public static class User {
		private String name;
		public volatile int old;

		public User(String name, int old) {
			this.name = name;
			this.old = old;
		}

		public String getName() {
			return name;
		}

		public int getOld() {
			return old;
		}
	}
}

输出

10
11

The above is the detailed content of Detailed introduction to code sharing used by the Atomic package in Java. For more information, please follow other related articles on the PHP Chinese website!