最近一直在忙各种乱七八糟的事,好久没写博客了,前两天以为要研究多线程的问题,所以把很多j.u.c包中的类的源码看了看,感觉收获了很多,下面给大家分享分享
首先分析几个比较简单也比较类似的类AtomicBoolean、AtomicInteger、AtomicLong,这几个都是线程安全的原始类型封装类,看看如何使用
public class AtomicIntegerTest {
static class AutoTest{
AtomicInteger atomicInteger = new AtomicInteger(0);
int b = 0;
public int atomicIntegerAdd(){
return atomicInteger.incrementAndGet();
}
public int getAtomic(){
return atomicInteger.get();
}
public int bAdd(){
return b++;
}
public int getB(){
return b;
}
}
public static void main(String[] args) throws InterruptedException {
final AutoTest autoTest = new AutoTest();
for (int i = 0; i < 100; i++) {
Runnable runnable = new Runnable() {
@Override
public void run() {
for (int j = 0; j < 100; j++) {
autoTest.atomicIntegerAdd();
autoTest.bAdd();
}
}
};
Thread thread = new Thread(runnable);
thread.start();
}
TimeUnit.SECONDS.sleep(10);
System.out.println(autoTest.getB());//9996
System.out.println(autoTest.getAtomic());//10000
}
}
由上面的结果可知AtomicInteger可以线程安全的自增,那这个是怎么实现的呢?咱们来看看它的源码,其主要属性如下
//unsafe类可直接操作内存.后面的cas都是通过unsafe来操作
private static final Unsafe unsafe = Unsafe.getUnsafe();
//保存value变量在内存中偏移量地址
private static final long valueOffset;
//实例化变量时获取偏移量地址
static {
try {
valueOffset = unsafe.objectFieldOffset
(AtomicInteger.class.getDeclaredField("value"));
} catch (Exception ex) { throw new Error(ex); }
}
//volatile类型变量,保证value的可见性,原子性通过unsafe的cas操作来保证
private volatile int value;
ps.这里有一个比较关键的点,volatile关键字,volatile关键字保证变量的可见性、防止指令重新排序,但它是如何保证可见性的呢?用volatile关键字修饰的变量不会放在寄存器中,而是放在主内存中,因此多个线程访问时保证其可见性(即不放在栈中,而放在堆中).
咱们来看看其中比较关键的几个方法
/**
直接设置volatile变量的值
*/
public final void set(int newValue) {
value = newValue;
}
/**
这个其实不是很理解是什么意思,网上搜到说法如下
putOrderedInt,去掉了storeLoad内存屏障,只保证最终设置成功,不保证多处理环境下,其他处理器read到最新的值
*/
public final void lazySet(int newValue) {
unsafe.putOrderedInt(this, valueOffset, newValue);
}
/**
不断循环以cas方式赋值,直到成功为止
*/
public final int getAndSet(int newValue) {
for (;;) {
int current = get();
if (compareAndSet(current, newValue))
return current;
}
}
/**
调用unsafe类的compareAndSwapInt实现cas操作
*/
public final boolean compareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
AtomicBoolean、AtomicLong的源码与AtomicInteger十分相似,这里就不列出了;这三个类其实都很简单,难的是理解Unsafe类的cas操作,但这个我也并不能说的十分清楚.
除了上述三个对基本类型的原子操作外,还有提供对引用类型的原子操作:AtomicReference,其用法、源码与基本类型原子操作基本一致,我这里不做分析
AtomicIntegerArray、AtomicLongArray、AtomicReferenceArray三个类分别是int型数组、long型数组、引用类型数组的原子操作类,结构与其基本类型操作十分相似,在此不做分析
AtomicIntegerFieldUpdater、AtomicLongFieldUpdater、AtomicReferenceFieldUpdater提供了对某个类中特定类型属性的原子操作;以AtomicIntegerFieldUpdater为例:
package com.kevindai.juc;
import sun.reflect.Reflection;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
public class AtomicIntegerFieldUpdaterTest {
static class AtomicFieldIncr {
//这里最好是public volatile,不要加final、static
//修饰符最好也不要为protected,private,涉及调用者访问被调用者的access问题
public volatile int idx;
public AtomicFieldIncr(){
}
public int getIdx(){
return this.idx;
}
public void setIdx(int idx){
this.idx = idx;
}
}
public static void main(String[] args) {
AtomicFieldIncr atomicFieldIncr = new AtomicFieldIncr();
AtomicIntegerFieldUpdater<AtomicFieldIncr> atomicFieldUpdater = AtomicIntegerFieldUpdater.newUpdater(AtomicFieldIncr.class , "idx");
atomicFieldUpdater.set(atomicFieldIncr, 3);
System.out.println(atomicFieldIncr.getIdx());
atomicFieldUpdater.compareAndSet(atomicFieldIncr, 3, 4);
System.out.println(atomicFieldIncr.getIdx());
}
}
AtomicIntegerFieldUpdater本身为abstract,内部提供static实现AtomicIntegerFieldUpdaterImpl,看下AtomicIntegerFieldUpdater的构造函数:
/**
tclass就是被调用类,也就是需要变量原子操作的类
fieldName:tclass中volatile变量
*/
@CallerSensitive
public static <U> AtomicIntegerFieldUpdater<U> newUpdater(Class<U> tclass, String fieldName) {
//Reflection.getCallerClass()获取我们的调用类,使用反射机制
return new AtomicIntegerFieldUpdaterImpl<U>(tclass, fieldName, Reflection.getCallerClass());
}
AtomicIntegerFieldUpdater定义了一些抽象方法,跟普通AtomicInteger一样,看下AtomicIntegerFieldUpdaterImpl的构造函数:
AtomicIntegerFieldUpdaterImpl(Class<T> tclass, String fieldName, Class<?> caller) {
Field field = null;
int modifiers = 0;
try {
//反射获取字段
field = tclass.getDeclaredField(fieldName);
modifiers = field.getModifiers();
//校验volatile变量的访问权限
//被调用者类中的volatile变量一般定义成public volatile不会有问题,如果是其他需要注意sun.reflect.misc.ReflectUtil.ensureMemberAccess(
caller, tclass, null, modifiers);
sun.reflect.misc.ReflectUtil.checkPackageAccess(tclass);
} catch (Exception ex) {
throw new RuntimeException(ex);
}
//检查字段类型
Class fieldt = field.getType();
if (fieldt != int.class)
throw new IllegalArgumentException("Must be integer type");
//检查字段是否为volatile
if (!Modifier.isVolatile(modifiers))
throw new IllegalArgumentException("Must be volatile type");
this.cclass = (Modifier.isProtected(modifiers) &&
caller != tclass) ? caller : null;
this.tclass = tclass;
offset = unsafe.objectFieldOffset(field);
}
这里最主要是检查字段权限,绝对不要定义成static/final,修饰符的问题还是看权限
实现类中的具体操作,大概流程都一样,先做校验,主要是校验你传入的类是否跟之前保存的被调用的类型一致,然后再调用unsafe的底层操作,代码很简单,我简单列出一下:
private void fullCheck(T obj) {
if (!tclass.isInstance(obj))
throw new ClassCastException();
if (cclass != null)
ensureProtectedAccess(obj);
}
public boolean compareAndSet(T obj, int expect, int update) {
if (obj == null || obj.getClass() != tclass || cclass != null) fullCheck(obj);
return unsafe.compareAndSwapInt(obj, offset, expect, update);
}
public boolean weakCompareAndSet(T obj, int expect, int update) {
if (obj == null || obj.getClass() != tclass || cclass != null) fullCheck(obj);
return unsafe.compareAndSwapInt(obj, offset, expect, update);
}
public void set(T obj, int newValue) {
if (obj == null || obj.getClass() != tclass || cclass != null) fullCheck(obj);
unsafe.putIntVolatile(obj, offset, newValue);
}
public void lazySet(T obj, int newValue) {
if (obj == null || obj.getClass() != tclass || cclass != null) fullCheck(obj);
unsafe.putOrderedInt(obj, offset, newValue);
}
public final int get(T obj) {
if (obj == null || obj.getClass() != tclass || cclass != null) fullCheck(obj);
return unsafe.getIntVolatile(obj, offset);
}
private void ensureProtectedAccess(T obj) {
if (cclass.isInstance(obj)) {
return;
}
throw new RuntimeException(
new IllegalAccessException("Class " +
cclass.getName() +
" can not access a protected member of class " +
tclass.getName() +
" using an instance of " +
obj.getClass().getName()
)
);
}
下面来看看解决CAS的ABA问题的一个类AtomicStampedReference,首先来看看如何使用:
public class AtomicStampedReferenceTest {
private static AtomicStampedReference<Integer> atomicStampedRef = new AtomicStampedReference<Integer>(100, 0);
public static void main(String[] args) {
Thread refT1 = new Thread(new Runnable() {
@Override
public void run() {
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
atomicStampedRef.compareAndSet(100, 101, atomicStampedRef.getStamp(), atomicStampedRef.getStamp() + 1);
atomicStampedRef.compareAndSet(101, 100, atomicStampedRef.getStamp(), atomicStampedRef.getStamp() + 1);
}
});
Thread refT2 = new Thread(new Runnable() {
@Override
public void run() {
int stamp = atomicStampedRef.getStamp();
System.out.println("before sleep: stamp = " + stamp);
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("after sleep: stamp = " + atomicStampedRef.getStamp());
boolean c3 = atomicStampedRef.compareAndSet(100, 101, stamp, stamp + 1);
System.out.println(c3); // false, 设置失败了,因为戳“stamp”的检查未通过
}
});
refT1.start();
refT2.start();
}
}
由上面的例子咱们可以知道,使用AtomicStampedReference时不仅要设置引用还要设置计数器,如果计数器不满足条件设值也会失败,下面咱们看看其是如何实现的:
/**
通过static pair保存一个引用和计数器,引用和计数器均为final
*/
private static class Pair<T> {
final T reference;
final int stamp;
private Pair(T reference, int stamp) {
this.reference = reference;
this.stamp = stamp;
}
static <T> Pair<T> of(T reference, int stamp) {
return new Pair<T>(reference, stamp);
}
}
private volatile Pair<V> pair;
/**
通过传入的初始化引用和计数器来构造函数一个pair
*/
public AtomicStampedReference(V initialRef, int initialStamp) {
pair = Pair.of(initialRef, initialStamp);
}
public boolean compareAndSet(V expectedReference,
V newReference,
int expectedStamp,
int newStamp) {
Pair<V> current = pair;
//每次操作前不但比较引用值还比较计数器,底层还是调用 Unsafe的方法
return
expectedReference == current.reference &&
expectedStamp == current.stamp &&
((newReference == current.reference &&
newStamp == current.stamp) ||
casPair(current, Pair.of(newReference, newStamp)));
}
private boolean casPair(Pair<V> cmp, Pair<V> val) {
return UNSAFE.compareAndSwapObject(this, pairOffset, cmp, val);
}
还有一些获取引用和计数器的方法我就不列出了;AtomicStampedReference主要是在其内部有一个Pairs对象用于保存引用和计数器,当进行赋值是,不仅要比较引用,还要比较计数器.
AtomicMarkableReference与AtomicStampedReference几乎一致,在此不做分析