这个过程是原子的。CAS汇编指令。这是一种完全依赖于硬件功能，通过它实现了原子操作。由于CAS是一种系统原语，原语属于操作系统用于范畴，是由若干条指令组成，用于完成某个功能的一个过程，并且原语的执行必须是连续的，在执行过程中不允许中断，也即是说CAS是一条原子指令，不会造成所谓的数据不一致的问题。CAS有3个操作数，内存位置值V，旧的预期值A，要修改的更新值B。当且仅当旧的预期值A和内存值V相等时，将内存值V修改为B，否则什么都不做或重来。
如果线程的期望值跟物理内存的真实值一样，就更新值到物理内存当中，并返回true。 如果线程的期望值跟物理内存的真实值不一样，返回是false，那么本次修改失败，那么此时需要重新获得主物理内存的新值。
public class CASTest1 {
public static void main ( String [ ] args) {
AtomicInteger atomicInteger = new AtomicInteger ( 5 ) ;
System . out. println ( "是否更新成功：" + atomicInteger. compareAndSet ( 5 , 10 ) + "，值为：" + atomicInteger. get ( ) ) ;
System . out. println ( "是否更新成功：" + atomicInteger. compareAndSet ( 5 , 20 ) + "，值为：" + atomicInteger. get ( ) ) ;
}
}
public class VolatileTest5 {
volatile int num = 0 ;
AtomicInteger atomicInteger = new AtomicInteger ( ) ;
public synchronized void addNum ( ) {
num ++ ;
}
public void addAtomicInteger ( ) {
atomicInteger. getAndIncrement ( ) ;
}
}
Unsafe类
重新读取重新来一遍了。
Unsafe类存在于sun.misc包中，其内部方法操作可以像C的指针一样直接操作内存，因为Java中CAS操作的执行依赖于Unsafe类的方法。注意Unsafe类中的所有方法都是native修饰的，也就是说Unsafe类中的方法都直接调用操作系统底层资源执行相应任务。Unsafe对象不能直接调用，要通过反射才能获得
public class Test {
public static void main ( String [ ] args) throws Exception {
Field theUnsafe = Unsafe . class . getDeclaredField ( "theUnsafe" ) ;
theUnsafe. setAccessible ( true ) ;
Unsafe unsafe = ( Unsafe ) theUnsafe. get ( null ) ;
System . out. println ( unsafe) ;
}
}
public class Test2 {
public static void main ( String [ ] args) throws Exception {
Field theUnsafe = Unsafe . class . getDeclaredField ( "theUnsafe" ) ;
theUnsafe. setAccessible ( true ) ;
Unsafe unsafe = ( Unsafe ) theUnsafe. get ( null ) ;
System . out. println ( unsafe) ;
long id = unsafe. objectFieldOffset ( Student . class . getDeclaredField ( "id" ) ) ;
long name = unsafe. objectFieldOffset ( Student . class . getDeclaredField ( "name" ) ) ;
Student s = new Student ( ) ;
unsafe. compareAndSwapInt ( s, id, 0 , 1 ) ;
unsafe. compareAndSwapObject ( s, name, null , "张三" ) ;
System . out. println ( s. getName ( ) ) ;
}
}
@Data
class Student {
private Integer id;
private String name;
}
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 long getAndAddLong ( Object var1, long var2, long var4) {
long var6;
do {
var6 = this . getLongVolatile ( var1, var2) ;
} while ( ! this . compareAndSwapLong ( var1, var2, var6, var6 + var4) ) ;
return var6;
}
public final int getAndSetInt ( Object var1, long var2, int var4) {
int var5;
do {
var5 = this . getIntVolatile ( var1, var2) ;
} while ( ! this . compareAndSwapInt ( var1, var2, var5, var4) ) ;
return var5;
}
public final long getAndSetLong ( Object var1, long var2, long var4) {
long var6;
do {
var6 = this . getLongVolatile ( var1, var2) ;
} while ( ! this . compareAndSwapLong ( var1, var2, var6, var4) ) ;
return var6;
}
public final Object getAndSetObject ( Object var1, long var2, Object var4) {
Object var5;
do {
var5 = this . getObjectVolatile ( var1, var2) ;
} while ( ! this . compareAndSwapObject ( var1, var2, var5, var4) ) ;
return var5;
}
compareAndSwapObject compareAndSwapInt compareAndSwapLong
public final native boolean compareAndSwapObject ( Object var1, long var2, Object var4, Object var5) ;
public final native boolean compareAndSwapInt ( Object var1, long var2, int var4, int var5) ;
public final native boolean compareAndSwapLong ( Object var1, long var2, long var4, long var6) ;
UNSAFE_ENTRY ( jboolean, Unsafe_CompareAndSwapInt ( JNIEnv * env, jobject unsafe, jobject obj, jlong offset, jint e, jint x) )
UnsafeWrapper ( "Unsafe_CompareAndSwapInt" ) ;
oop p = JNIHandles:: resolve ( obj) ;
jint* addr = ( jint * ) index_oop_from_field_offset_long ( p, offset) ;
return ( jint) ( Atomic:: cmpxchg ( x, addr, e) ) == e;
UNSAFE_END
unsigned Atomic:: cmpxchg ( unsigned int exchange_value, volatile unsigned int * dest, unsigned int compare_value) {
assert ( sizeof ( unsigned int ) == sizeof ( jint) , "more work to do" ) ;
return ( unsigned int ) Atomic:: cmpxchg ( ( jint) exchange_value, ( volatile jint* ) dest, ( jint) compare_value) ;
}
inline jint Atomic:: cmpxchg ( jint exchange_value, volatile jint* dest, jint compare_value) {
int mp = os:: is_MP ( ) ;
__asm {
mov edx, dest
mov ecx, exchange_value
mov eax, compare_value
LOCK_IF_MP ( mp)
cmpxchg dword ptr [ edx] , ecx
}
}
CAS是靠硬件实现的从而在硬件层面提升效率，最底层还是交给硬件来保证原子性和可见性。 实现方式是基于硬件平台的汇编指令，在intel的CPU中(X86机器上)，使用的是汇编指令cmpxchg指令。 核心思想就是：比较要更新变量的值V和预期值E（compare），相等才会将V的值设为新值N（swap）如果不相等自旋再来。
循环时间长开销大：方法中有一个do while，如果CAS失败，会一直进行尝试，如果长时间不成功，可能会给CPU带来很大的开销。
只能保证一个共享变量的原子操作： ABA问题：
public class ABAQuestion {
static AtomicReference < String > = new AtomicReference < > ( "A" ) ;
public static void main ( String [ ] args) throws InterruptedException {
new Thread ( ( ) -> {
System . out. println ( "线程 " + Thread . currentThread ( ) . getName ( ) + " change A -> B " + reference. compareAndSet ( reference. get ( ) , "B" ) ) ;
System . out. println ( "线程 " + Thread . currentThread ( ) . getName ( ) + " change B -> A " + reference. compareAndSet ( reference. get ( ) , "A" ) ) ;
} , "t1" ) . start ( ) ;
Thread . sleep ( 1000 ) ;
new Thread ( ( ) -> {
System . out. println ( "线程 " + Thread . currentThread ( ) . getName ( ) + " change A -> C " + reference. compareAndSet ( reference. get ( ) , "C" ) ) ;
} , "t2" ) . start ( ) ;
}
}
AtomicStampedReference与AtomicMarkableReference原子引用类来解决ABA问题。 AtomicStampedReference 本质是有一个int值作为版本号，每次更改前先取到这个int值的版本号，等到修改的时候，比较当前版本号与当前线程持有的版本号是否一致，如果一致，则进行修改，并修改版本号（通常+1能明确知道被修改过几次）。 AtomicMarkableReference不再用int标识引用，而是将一个boolean值作是否有更改的标记，本质就是它的版本号只有两个，true和false，修改的时候在这两个版本号之间来回切换，这样做并不能解决ABA的问题，只是会降低ABA问题发生的几率而已。
public class SolveABAQuestion {
static AtomicStampedReference < String > = new AtomicStampedReference < > ( "A" , 1 ) ;
public static void main ( String [ ] args) throws InterruptedException {
new Thread ( ( ) -> {
int stamp = reference1. getStamp ( ) ;
System . out. println ( "线程 " + Thread . currentThread ( ) . getName ( ) + " 初始版本号 " + stamp) ;
try {
Thread . sleep ( 1000 ) ;
} catch ( InterruptedException e) {
e. printStackTrace ( ) ;
}
boolean oneFlag = reference1. compareAndSet ( "A" , "B" , reference1. getStamp ( ) , reference1. getStamp ( ) + 1 ) ;
System . out. println ( "线程 " + Thread . currentThread ( ) . getName ( ) + " change A -> B " + oneFlag + " 最新值为 " + reference1. getReference ( ) + " 版本号为 " + reference1. getStamp ( ) ) ;
boolean twoFlag = reference1. compareAndSet ( "B" , "A" , reference1. getStamp ( ) , reference1. getStamp ( ) + 1 ) ;
System . out. println ( "线程 " + Thread . currentThread ( ) . getName ( ) + " change B -> A " + twoFlag + " 最新值为 " + reference1. getReference ( ) + " 版本号为 " + reference1. getStamp ( ) ) ;
} , "t1" ) . start ( ) ;
new Thread ( ( ) -> {
int stamp = reference1. getStamp ( ) ;
System . out. println ( "线程 " + Thread . currentThread ( ) . getName ( ) + " 初始版本号 " + stamp) ;
try {
Thread . sleep ( 2000 ) ;
} catch ( InterruptedException e) {
e. printStackTrace ( ) ;
}
boolean flag = reference1. compareAndSet ( "A" , "C" , stamp, stamp + 1 ) ;
System . out. println ( "线程 " + Thread . currentThread ( ) . getName ( ) + " change A -> C " + flag + " 最新值为 " + reference1. getReference ( ) + " 版本号为 " + reference1. getStamp ( ) ) ;
} , "t2" ) . start ( ) ;
}
}
AtomicBoolean、AtomicInteger、AtomicLong public final int get()：获取当前的值。 public final int getAndSet(int newValue)：获取当前的值，并设置新的值 public final int getAndIncrement()：获取当前的值，并加1 public final int incrementAndGet()：将当前值加1，并返回 public final int getAndDecrement()：获取当前的值，并减1 public final int decrementAndGet()：将当前值减1，并返回 public final int getAndAdd(int delta)：获取当前的值，并加上预期的值 public final int addAndGet(int delta)：加上预期的值，并返回 public final boolean compareAndSet(int expect, int update)：如果输入的数值等于预期值，则以原子方式将该值设置为输入值（update）
AtomicIntegerArray：原子更新整型数组里的元素 AtomicLongArray：原子长整型数组里的元素 AtomicReferenceArray：原子引用类型数组里的元素
AtomicReference：原子更新引用类型 AtomicStampedReference：携带版本号的引用类型原子类，可以解决ABA问题，用int值作为版本号 AtomicMarkableReference：原子更新带有标记位的引用类型对象，用boolean值作是否有更改的标记，并不能很好的解决ABA问题
public class AtomicMarkableReferenceTest {
static AtomicMarkableReference < String > = new AtomicMarkableReference < > ( "A" , false ) ;
public static void main ( String [ ] args) throws InterruptedException {
new Thread ( ( ) -> {
boolean marked = reference1. isMarked ( ) ;
System . out. println ( "线程 " + Thread . currentThread ( ) . getName ( ) + " 初始标记 " + marked) ;
try {
Thread . sleep ( 1000 ) ;
} catch ( InterruptedException e) {
e. printStackTrace ( ) ;
}
boolean flag = reference1. compareAndSet ( "A" , "B" , marked, ! marked) ;
System . out. println ( "线程 " + Thread . currentThread ( ) . getName ( ) + " change A -> B " + flag + " 最新值为 " + reference1. getReference ( ) + " 标记为 " + reference1. isMarked ( ) ) ;
} , "t1" ) . start ( ) ;
new Thread ( ( ) -> {
boolean marked = reference1. isMarked ( ) ;
System . out. println ( "线程 " + Thread . currentThread ( ) . getName ( ) + " 初始标记 " + marked) ;
try {
Thread . sleep ( 2000 ) ;
} catch ( InterruptedException e) {
e. printStackTrace ( ) ;
}
boolean flag = reference1. compareAndSet ( "A" , "C" , marked, ! marked) ;
System . out. println ( "线程 " + Thread . currentThread ( ) . getName ( ) + " change A -> C " + flag + " 最新值为 " + reference1. getReference ( ) + " 版本号为 " + reference1. isMarked ( ) ) ;
} , "t2" ) . start ( ) ;
}
}
在内部通过Unsafe类的native方法保证操作的原子性。 AtomicIntegerFieldUpdater：基于反射的工具类，可以原子性的更新指定对象中int类型字段 AtomicLongFieldUpdater：基于反射的工具类，可以原子性的更新指定对象中long类型字段 AtomicReferenceFieldUpdater：基于反射的工具类，可以原子性的更新指定对象中引用类型字段。 属性字段必须是volatile类型，用于保证可见性，否则报错java.lang.IllegalArgumentException: Must be volatile type 属性类型必须和原子类中的类型一致。 属性字段必须非private、protected（如果是当前类是可以的）。 属性字段只能是实例变量，不能是类变量（static）。 属性字段不能是final变量，因为这样的字段不可修改。 如果要处理Integer和Long类型，则需要使用AtomicReferenceFieldUpdater。
public class AtomicIntegerFieldUpdaterTest {
public static void main ( String [ ] args) throws InterruptedException {
User user = new User ( ) ;
for ( int i = 1 ; i <= 10000 ; i++ ) {
int j = i;
new Thread ( ( ) -> {
user. addScore ( user) ;
} , String . valueOf ( i) ) . start ( ) ;
}
Thread . sleep ( 5000 ) ;
System . out. println ( "结果：" + user. score) ;
}
}
class User {
private String name;
public volatile int score;
AtomicIntegerFieldUpdater < User > = AtomicIntegerFieldUpdater . newUpdater ( User . class , "score" ) ;
public void addScore ( ) {
score = score + 1 ;
}
public void addScore ( User user) {
fieldUpdater. incrementAndGet ( user) ;
}
}
减少乐观锁的重试次数）。 DoubleAccumulator：一个或多个变量共同维护使用提供的函数更新的运行double值 DoubleAdder：一个或多个变量共同保持初始为零的double和 LongAccumulator：一个或多个变量共同维护使用提供的函数更新的运行long值 LongAdder：一个或多个变量共同保持初始为零的long和
方法 说明 LongAdder() 只有一个无参的构造器，会构造一个sum=0的实例对象 void add(long x) 增量计算，+x void increment() 自增（+1） void decrement() 自减（-1） long sum() 返回当前的总和，不存在并发的情况下，会返回精确值，存在并发下，不保证精确值 void reset() 重置为零，可用于替代重新new一个LongAdder，只能在没有并发情况下使用 long sumThenReset() 计算sum的和并重置sum为0
public class compareAtomicLongAndLongAdder {
private static final int ADD_COUNT = 10000 ;
private static final int THREAD_COUNT = 50 ;
public static void main ( String [ ] args) throws InterruptedException {
long startTime, endTime;
CompareResource compareResource = new CompareResource ( ) ;
CountDownLatch c1 = new CountDownLatch ( THREAD_COUNT) ;
CountDownLatch c2 = new CountDownLatch ( THREAD_COUNT) ;
CountDownLatch c3 = new CountDownLatch ( THREAD_COUNT) ;
CountDownLatch c4 = new CountDownLatch ( THREAD_COUNT) ;
startTime = System . currentTimeMillis ( ) ;
for ( int i = 1 ; i <= THREAD_COUNT; i++ ) {
new Thread ( ( ) -> {
try {
for ( int j = 1 ; j <= 100 * ADD_COUNT; j++ ) {
compareResource. addSynchronizedNum ( ) ;
}
} finally {
c1. countDown ( ) ;
}
} , String . valueOf ( i) ) . start ( ) ;
}
c1. await ( ) ;
endTime = System . currentTimeMillis ( ) ;
System . out. println ( "使用Synchronized方式计算耗时：" + ( endTime - startTime) + " 毫秒" + " 最后结果: " + compareResource. number) ;
startTime = System . currentTimeMillis ( ) ;
for ( int i = 1 ; i <= THREAD_COUNT; i++ ) {
new Thread ( ( ) -> {
try {
for ( int j = 1 ; j <= 100 * ADD_COUNT; j++ ) {
compareResource. addAtomicLongNum ( ) ;
}
} finally {
c2. countDown ( ) ;
}
} , String . valueOf ( i) ) . start ( ) ;
}
c2. await ( ) ;
endTime = System . currentTimeMillis ( ) ;
System . out. println ( "使用AtomicLong方式计算耗时：" + ( endTime - startTime) + " 毫秒" + " 最后结果: " + compareResource. atomicLong. get ( ) ) ;
startTime = System . currentTimeMillis ( ) ;
for ( int i = 1 ; i <= THREAD_COUNT; i++ ) {
new Thread ( ( ) -> {
try {
for ( int j = 1 ; j <= 100 * ADD_COUNT; j++ ) {
compareResource. addLongAdderNum ( ) ;
}
} finally {
c3. countDown ( ) ;
}
} , String . valueOf ( i) ) . start ( ) ;
}
c3. await ( ) ;
endTime = System . currentTimeMillis ( ) ;
System . out. println ( "使用LongAdder方式计算耗时：" + ( endTime - startTime) + " 毫秒" + " 最后结果: " + compareResource. longAdder. sum ( ) ) ;
startTime = System . currentTimeMillis ( ) ;
for ( int i = 1 ; i <= THREAD_COUNT; i++ ) {
new Thread ( ( ) -> {
try {
for ( int j = 1 ; j <= 100 * ADD_COUNT; j++ ) {
compareResource. addLongAccumulatorNum ( ) ;
}
} finally {
c4. countDown ( ) ;
}
} , String . valueOf ( i) ) . start ( ) ;
}
c4. await ( ) ;
endTime = System . currentTimeMillis ( ) ;
System . out. println ( "使用LongAccumulator方式计算耗时：" + ( endTime - startTime) + " 毫秒" + " 最后结果: " + compareResource. longAccumulator. get ( ) ) ;
}
}
class CompareResource {
public int number = 0 ;
public synchronized void addSynchronizedNum ( ) {
number ++ ;
}
AtomicLong atomicLong = new AtomicLong ( 0 ) ;
public void addAtomicLongNum ( ) {
atomicLong. getAndIncrement ( ) ;
}
LongAdder longAdder = new LongAdder ( ) ;
public void addLongAdderNum ( ) {
longAdder. increment ( ) ;
}
LongAccumulator longAccumulator = new LongAccumulator ( ( x, y) -> x + y, 0 ) ;
public void addLongAccumulatorNum ( ) {
longAccumulator. accumulate ( 1 ) ;
}
}
初始化时，通过Unsafe获取到类字段的偏移值，以便后续CAS操作。
abstract class Striped64 extends Number {
Striped64 ( ) {
}
private static final sun. misc. Unsafe;
private static final long BASE;
private static final long CELLSBUSY;
private static final long PROBE;
static {
try {
UNSAFE = sun. misc. Unsafe. getUnsafe ( ) ;
Class < ? > = Striped64 . class ;
BASE = UNSAFE. objectFieldOffset
( sk. getDeclaredField ( "base" ) ) ;
CELLSBUSY = UNSAFE. objectFieldOffset
( sk. getDeclaredField ( "cellsBusy" ) ) ;
Class < ? > = Thread . class ;
PROBE = UNSAFE. objectFieldOffset
( tk. getDeclaredField ( "threadLocalRandomProbe" ) ) ;
} catch ( Exception e) {
throw new Error ( e) ;
}
}
}
static final int NCPU = Runtime . getRuntime ( ) . availableProcessors ( ) ;
transient volatile Cell [ ] cells;
transient volatile long base;
transient volatile int cellsBusy;
final boolean casCellsBusy ( ) {
return UNSAFE. compareAndSwapInt ( this , CELLSBUSY, 0 , 1 ) ;
}
static final int getProbe ( ) {
return UNSAFE. getInt ( Thread . currentThread ( ) , PROBE) ;
}
static final int advanceProbe ( int probe) {
probe ^= probe << 13 ;
probe ^= probe >>> 17 ;
probe ^= probe << 5 ;
UNSAFE. putInt ( Thread . currentThread ( ) , PROBE, probe) ;
return probe;
}
Cell 类（也就是槽），每个Cell对象存有一个value值，可以通过Unsafe来CAS操作它的值
@sun.misc.Contended static final class Cell {
volatile long value;
Cell ( long x) { value = x; }
final boolean cas ( long cmp, long val) {
return UNSAFE. compareAndSwapLong ( this , valueOffset, cmp, val) ;
}
private static final sun. misc. Unsafe;
private static final long valueOffset;
static {
try {
UNSAFE = sun. misc. Unsafe. getUnsafe ( ) ;
Class < ? > = Cell . class ;
valueOffset = UNSAFE. objectFieldOffset
( ak. getDeclaredField ( "value" ) ) ;
} catch ( Exception e) {
throw new Error ( e) ;
}
}
}
分散热点，将value值分散到一个Cell数组中，不同线程会命中到数组的不同槽中，各个线程只对自己槽中的那个值进行CAS操作，这样热点就被分散了，冲突的概率也就小很多，如果要获取真正的long值，只要将各个槽中的变量值累加返回。核心思想就是将AtomicLong的一个value的更新压力分散到多个value上进行更新。3、LongAdder原理： 当所有线程操作完毕，将数组cells的所有值和无竞争值base都加起来作为最终结果。
最终结果
=
B
a
s
e
+
∑
i
=
n
n
C
e
l
l
[
i
]
最终结果 = Base + \sum_{i=n}^{n}Cell[i]
最终结果 = B a se + i = n ∑ n C e ll [ i ]
public void add ( long x) {
Cell [ ] as; long b, v; int m; Cell a;
if ( ( as = cells) != null || ! casBase ( b = base, b + x) ) {
boolean uncontended = true ;
if ( as == null || ( m = as. length - 1 ) < 0 ||
( a = as[ getProbe ( ) & m] ) == null || ! ( uncontended = a. cas ( v = a. value, v + x) ) )
longAccumulate ( x, null , uncontended) ;
}
}
在LongAccumulator可以自定义计算 只有cells初始化之后，并且当前线程CAS竞争修改失败，才会是false。
final void longAccumulate ( long x, LongBinaryOperator fn, boolean wasUncontended) {
int h;
if ( ( h = getProbe ( ) ) == 0 ) {
ThreadLocalRandom . current ( ) ;
h = getProbe ( ) ;
wasUncontended = true ;
}
boolean collide = false ;
for ( ; ; ) {
Cell [ ] as; Cell a; int n; long v;
if ( ( as = cells) != null && ( n = as. length) > 0 ) {
}
else if ( cellsBusy == 0 && cells == as && casCellsBusy ( ) ) {
boolean init = false ;
try {
if ( cells == as) {
Cell [ ] rs = new Cell [ 2 ] ;
rs[ h & 1 ] = new Cell ( x) ;
cells = rs;
init = true ;
}
} finally {
cellsBusy = 0 ;
}
if ( init)
break ;
}
else if ( casBase ( v = base, ( ( fn == null ) ? v + x :
fn. applyAsLong ( v, x) ) ) )
break ;
}
}
Cell数组已经初始化的情况，流程图如下：
Cell [ ] as; Cell a; int n; long v;
if ( ( as = cells) != null && ( n = as. length) > 0 ) {
if ( ( a = as[ ( n - 1 ) & h] ) == null ) {
if ( cellsBusy == 0 ) {
Cell r = new Cell ( x) ;
if ( cellsBusy == 0 && casCellsBusy ( ) ) {
boolean created = false ;
try {
Cell [ ] rs; int m, j;
if ( ( rs = cells) != null &&
( m = rs. length) > 0 &&
rs[ j = ( m - 1 ) & h] == null ) {
rs[ j] = r;
created = true ;
}
} finally {
cellsBusy = 0 ;
}
if ( created)
break ;
continue ;
}
}
collide = false ;
}
else if ( ! wasUncontended)
wasUncontended = true ;
else if ( a. cas ( v = a. value, ( ( fn == null ) ? v + x : fn. applyAsLong ( v, x) ) ) )
break ;
else if ( n >= NCPU || cells != as)
collide = false ;
else if ( ! collide)
collide = true ;
else if ( cellsBusy == 0 && casCellsBusy ( ) ) {
try {
if ( cells == as) {
Cell [ ] rs = new Cell [ n << 1 ] ;
for ( int i = 0 ; i < n; ++ i)
rs[ i] = as[ i] ;
cells = rs;
}
} finally {
cellsBusy = 0 ;
}
collide = false ;
continue ;
}
h = advanceProbe ( h) ;
}
sum方法会将当前时刻所有Cell数组中的value和base累加作为返回值。
public long sum ( ) {
Cell [ ] as = cells; Cell a;
long sum = base;
if ( as != null ) {
for ( int i = 0 ; i < as. length; ++ i) {
if ( ( a = as[ i] ) != null )
sum += a. value;
}
}
return sum;
}
@sun.misc.Contended：对某字段加上该注解则表示该字段会单独占用一个缓存行（Cache Line）。这里的缓存行是指CPU缓存（L1、L2、L3）的存储单元，常见的缓存行大小为64字节。单独使用一个缓存行有什么作用 — 避免伪共享： 当一个CPU要修改某共享变量A时会先锁定自己缓存里A所在的缓存行，并且把其他CPU缓存上相关的缓存行设置为无效。但如果被锁定或失效的缓存行里，还存储了其他不相干的变量B，其他线程此时就访问不了B，或者由于缓存行失效需要重新从内存中读取加载到缓存里，这里造成了开销，所以让共享变量A单独使用一个缓存行就不会影响到其他线程的访问。
从CPU到 大约需要的时间周期 寄存器 1 cycle（4GHz 的 CPU 约为0.25ns） L1 3-4 cycle L2 10-20 cycle L3 40-45 cycle 内存 120-240 cycle
Cell[0] = 6000,Cell[1]=8000要累加Cell[0] = 6001,Cell[1]=8000，这时会让Core-1的缓存行失效。 @sun.misc.Contended用来解决这个问题，它的原理是在使用此注解的对象或字段的前后各增加128字节大小的padding，从而让CPU将对象预读至缓存时占用不同的缓存行，这样，不会造成对方缓存行的失效。
2432
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
