原子操作类
AtomicInteger 源码解析
java.util.concurrent.atomic下的所有原子操作类都实现了 CAS。
AtomicInteger 内部维护一个变量 Unsafe：
private static final Unsafe unsafe = Unsafe.getUnsafe();
Unsafe 类中可以执行以下几种操作：
-
分配内存，释放内存。allocateMemory，reallocateMemory，freeMemory -
挂起和唤醒线程。被封装在 LockSupport 类中供使用 -
CAS 操作
J.U.C 包里面的整数原子类 AtomicInteger 的方法调用了 Unsafe 类的 CAS 操作。
以下代码使用了 AtomicInteger 执行了自增的操作。
private AtomicInteger cnt = new AtomicInteger();
public void add() {
cnt.incrementAndGet();
}
以下代码是 incrementAndGet() 的源码，它调用了 Unsafe 的 getAndAddInt() 。
public final int incrementAndGet() {
return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}
以下代码是 getAndAddInt() 源码，var1 指示对象内存地址，var2 指示该字段相对对象内存地址的偏移，var4 指示操作需要加的数值，这里为 1。通过 getIntVolatile(var1, var2) 得到旧的预期值，通过调用 compareAndSwapInt() 来进行 CAS 比较，如果该字段内存地址中的值等于 var5，那么就更新内存地址为 var1+var2 的变量为 var5+var4。
可以看到 getAndAddInt() 在一个循环中进行，发生冲突的做法是不断的进行重试。
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;
}
除了 CAS 操作外，AtomicInteger 还使用 volatile 和 native 方法来保证原子操作，从而避免 synchronized 的高开销，执行效率大为提升。
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;
UnSafe 类的 objectFieldOffset() 方法是一个 native 方法，这个方法是用来拿到 “原来的值” 的内存地址，返回值是 valueOffset。
另外 value 是一个volatile变量，在内存中可见，因此 JVM 可以保证任何时刻任何线程总能拿到该变量的最新值。
原子更新基本类
atomic 包提高原子更新基本类的工具类，如下：
-
AtomicBoolean -
AtomicInteger -
AtomicLong
以 AtomicInteger 为例总结常用的方法:
addAndGet(int delta) //以原子方式将输入的数值与实例中原本的值相加，并返回最后的结果
incrementAndGet() //以原子的方式将实例中的原值进行加1操作，并返回最终相加后的结果
getAndSet(int newValue) //将实例中的值更新为新值，并返回旧值
getAndIncrement() //以原子的方式将实例中的原值加1，返回的是自增前的旧值
AtomicInteger 的 getAndIncrement() 方法源码如下：
public final int getAndIncrement() {
return unsafe.getAndAddInt(this, valueOffset, 1);
}
测试用例：
public class AtomicIntegerDemo {
// 请求总数
public static int clientTotal = 5000;
// 同时并发执行的线程数
public static int threadTotal = 200;
//java.util.concurrent.atomic.AtomicInteger;
public static AtomicInteger count = new AtomicInteger(0);
public static void main(String[] args) throws InterruptedException {
ExecutorService executorService = Executors.newCachedThreadPool();
//Semaphore和CountDownLatch模拟并发
//Semaphore 控制并发的数量
//CountDownLatch 用于控制一个线程等待多个线程
final Semaphore semaphore = new Semaphore(threadTotal);
final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
for (int i = 0; i < clientTotal ; i++) {
executorService.execute(() -> {
try {
semaphore.acquire();
add();
semaphore.release();
} catch (Exception e) {
e.printStackTrace();
}
countDownLatch.countDown();
});
}
countDownLatch.await();
executorService.shutdown();
System.out.println("count:{"+count.get()+"}");
}
public static void add() {
count.incrementAndGet();
}
}
输出结果：
count:{5000}
AtomicLong 的实现原理和 AtomicInteger 一致，只不过针对的是 long 变量。 boolean 变量的更新类 AtomicBoolean 类核心方法是 compareAndSet() 方法，其源码如下：
public final boolean compareAndSet(boolean expect, boolean update) {
int e = expect ? 1 : 0;
int u = update ? 1 : 0;
return unsafe.compareAndSwapInt(this, valueOffset, e, u);
}
可以看出，compareAndSet 方法的实际上也是先转换成 0,1 的整型变量，然后是通过针对 int 型变量的原子更新方法 compareAndSwapInt 来实现的。
原子更新数组
atomic 包下提供能原子更新数组中元素的类有：
-
AtomicIntegerArray -
AtomicLongArray -
AtomicReferenceArray
这几个类的用法一致，就以AtomicIntegerArray来总结下常用的方法：
getAndAdd(int i, int delta) //以原子更新的方式将数组中索引为i的元素与输入值相加
getAndIncrement(int i) //以原子更新的方式将数组中索引为i的元素自增加1
compareAndSet(int i, int expect, int update) //将数组中索引为i的位置的元素进行更新
可以看出，AtomicIntegerArray 与AtomicInteger 的方法基本一致，只不过在 AtomicIntegerArray 的方法中会多一个指定数组索引位 i。
public class AtomicIntegerArrayDemo {
private static int[] value = new int[]{1, 2, 3};
private static AtomicIntegerArray integerArray = new AtomicIntegerArray(value);
public static void main(String[] args) {
//对数组中索引为1的位置的元素加5
int result = integerArray.getAndAdd(1, 5);
System.out.println(integerArray.get(1));
System.out.println(result);
}
}
输出结果：
7
2 //注意仍然返回原来的旧值
原子更新引用类型
如果需要原子更新引用类型变量的话，为了保证线程安全，atomic 也提供了相关的类：
-
AtomicReference -
AtomicReferenceFieldUpdater。原子更新引用类型里的字段。 -
AtomicMarkableReference。原子更新带有标记位的引用类型。
这几个类的使用方法也是基本一样的，以AtomicReference为例。
public class AtomicReferenceDemo {
private static AtomicReference<User> reference = new AtomicReference<>();
public static void main(String[] args) {
User user1 = new User("a", 1);
reference.set(user1);
User user2 = new User("b",2);
User user = reference.getAndSet(user2);
System.out.println(user);
System.out.println(reference.get());
}
static class User {
private String userName;
private int age;
public User(String userName, int age) {
this.userName = userName;
this.age = age;
}
@Override
public String toString() {
return "User{" +
"userName='" + userName + '\'' +
", age=" + age +
'}';
}
}
}
输出结果：
User{userName='a', age=1}
User{userName='b', age=2}
首先将对象 user1 用 AtomicReference 进行封装，然后调用 getAndSet 方法，从结果可以看出，该方法会原子更新引用的 User 对象，变为User{userName='b', age=2}，返回的是原来的User 对象User{userName='a', age=1}。
原子更新字段类型
如果需要更新对象的某个字段，并在多线程的情况下，能够保证线程安全，atomic同样也提供了相应的原子操作类：
-
AtomicIntegeFieldUpdater -
AtomicLongFieldUpdater -
AtomicStampedReference。原子更新引用类型，这种更新方式会带有版本号，为了解决 CAS 的 ABA 问题。
要想使用原子更新字段需要两步操作：
-
原子更新字段类都是抽象类，只能通过静态方法 newUpdater 来创建一个更新器，并且需要设置想要更新的类和属性
-
更新类的属性必须使用 public volatile 进行修饰
这几个类提供的方法基本一致，以 AtomicIntegerFieldUpdater 为例。
public class AtomicIntegerFieldUpdaterDemo {
private static AtomicIntegerFieldUpdater updater =
AtomicIntegerFieldUpdater.newUpdater(User.class,"age");
public static void main(String[] args) {
User user = new User("a", 1);
int oldValue = updater.getAndAdd(user, 5);
System.out.println(oldValue);
System.out.println(updater.get(user));
}
static class User {
private String userName;
public volatile int age;
public User(String userName, int age) {
this.userName = userName;
this.age = age;
}
@Override
public String toString() {
return "User{" +
"userName='" + userName + '\'' +
", age=" + age +
'}';
}
}
}
输出结果：
1
6
创建 AtomicIntegerFieldUpdater 是通过它提供的静态方法进行创建，getAndAdd 方法会将指定的字段加上输入的值，并且返回相加之前的值。 User对象中 age 字段原值为 1，加 5 之后，可以看出 user 对象中的 age 字段的值已经变成了 6。
获取更多干货内容，记得关注我哦。
本文由 mdnice 多平台发布
扫一扫
229
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
