J.U.C Atomic（二）基本类型原子操作
java.util.concurrent.atomic包中对基本类型进行原子操作的类有：AtomicInteger、AtomicBoolean、AtomicLong。
下面通过一个测试程序来验证一下AtomicInteger真的实现了原子操作
public class AtomicIntegerTest { public static AtomicInteger count=new AtomicInteger(0); public static void main(String[] args) throws IOException { /*一个线程递增10000次*/ new Thread() { public void run() { for (int i = 0; i < 10000; i++) { System.out.println(this.getName() + ">>" + count.addAndGet(1)); } } }.start(); /* * 两个线程分别递减5000次 */ new Thread() { public void run() { for (int i = 0; i < 5000; i++) { System.out.println(this.getName() + ">>" + count.addAndGet(-1)); } } }.start(); new Thread() { public void run() { for (int i = 0; i < 5000; i++) { System.out.println(this.getName() + ">>" + count.addAndGet(-1)); } } }.start(); System.in.read(); System.out.println("最终结果："+count); } }
按照我们的预期如果最终结果是0，那么就可以说明确实实现了原子操作。
通过查看源码发现update操作最终都是通过调用compareAndSet方法，也就是通过Unsafe调用C程序执行CPU命令。
/**
* Atomically sets to the given value and returns the old value.
*
* @param newValue the new value
* @return the previous value
*/
public final int getAndSet(int newValue) {
for (;;) {
int current = get();
if (compareAndSet(current, newValue))
return current;
}
}
/**
* Atomically increments by one the current value.
*
* @return the previous value
*/
public final int getAndIncrement() {
for (;;) {
int current = get();
int next = current + 1;
if (compareAndSet(current, next))
return current;
}
}
public final boolean compareAndSet(int expect, int update) { return unsafe.compareAndSwapInt(this, valueOffset, expect, update); }
另外，这种自旋的方式保证操作成功的方式在竞争激烈的情况对CPU资源消耗比较大。
因为基本类型的原子类都比较近简单，实现方式也比较接近，在这就不细说了。
AtomicBoolean 最终也是调用了unsafe.compareAndSwapInt方法，
AtomicLong最终调用了unsafe.compareAndSwapLong方法，AtomicLong会多一个判断虚拟机是否支持long型无锁CompareAndSet，不过好像也没用它做任何事，意义何在呢？？？
/** * Records whether the underlying JVM supports lockless * compareAndSwap for longs. While the Unsafe.compareAndSwapLong * method works in either case, some constructions should be * handled at Java level to avoid locking user-visible locks. */ static final boolean VM_SUPPORTS_LONG_CAS = VMSupportsCS8(); /** * Returns whether underlying JVM supports lockless CompareAndSet * for longs. Called only once and cached in VM_SUPPORTS_LONG_CAS. */ private static native boolean VMSupportsCS8();
延伸知识点
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();//Unsafe仅供JDK内部调用，我们写的程序不能直接调用 private static final long valueOffset;//value相对对象地址的偏移量 static { try { valueOffset = unsafe.objectFieldOffset (AtomicInteger.class.getDeclaredField("value")); } catch (Exception ex) { throw new Error(ex); } } private volatile int value;//用volatile修饰，value值被某个线程修改后其他线程可以读到最新值
AtomicInteger有个属性valueOffset，并且通过静态代码块来初始化。valueOffet就是属性value相对AtomicInteger对象起始地址的偏移量，比如AtomicInteger对象实例化以后地址是1，valueOffet=N，那么value属性的起始地址就是1+N，做compareAndSwap的时候就可以直接定位到value的地址。
具体原理还要从Java对象内存布局说起：
在HotSpot虚拟机中，对象的内存布局可以分为三部分：对象头（Header）、 实例数据（Instance Data）和对齐填充（Padding）。
- 对象头
- 存储对象自身的运行时数据：Mark Word（在32bit和64bit虚拟机上长度分别为32bit和64bit），包含如下信息：
- 对象hashCode
- 对象GC分代年龄
- 锁状态标志（轻量级锁、重量级锁）
- 线程持有的锁（轻量级锁、重量级锁）
- 偏向锁相关：偏向锁、自旋锁、轻量级锁以及其他的一些锁优化策略是JDK1.6加入的
- 类型指针：对象指向类元数据的指针（32bit-->32bit，64bit-->64bit(未开启压缩指针)，32bit(开启压缩指针)）
-
JVM通过这个指针来确定这个对象是哪个类的实例（根据对象确定其Class的指针）
-
- 实例数据：对象真正存储的有效信息
- 对齐填充
- JVM要求对象的大小必须是8的整数倍，若不是，需要补位对齐
