LongAdder源码分析
AtomicLong是作用是对长整形进行原子操作，显而易见，在java1.8中新加入了一个新的原子类LongAdder，该类也可以保证Long类型操作的原子性，相对于AtomicLong，LongAdder有着更高的性能和更好的表现，可以完全替代AtomicLong的来进行原子操作。
AtomicLong的代码很简单，下面仅以incrementAndGet()为例，对AtomicLong的原理进行说明。
incrementAndGet()源码如下：
public final long incrementAndGet() { for (;;) { // 获取AtomicLong当前对应的long值 long current = get(); // 将current加1 long next = current + 1; // 通过CAS函数，更新current的值 if (compareAndSet(current, next)) return next; } } // value是AtomicLong对应的long值 private volatile long value; // 返回AtomicLong对应的long值 public final long get() { return value; } public final boolean compareAndSet(long expect, long update) { return unsafe.compareAndSwapLong(this, valueOffset, expect, update); } compareAndSet()的作用是更新AtomicLong对应的long值。它会比较AtomicLong的原始值是否与expect相等，若相等的话，则设置AtomicLong的值为update。
比AtomicLong更高效的LongAdder
AtomicLong的实现方式是内部有个value 变量，当多线程并发自增，自减时，均通过cas 指令从机器指令级别操作保证并发的原子性。
AtomicLong的实现方式是内部有个value 变量，当多线程并发自增，自减时，均通过CAS 指令从机器指令级别操作保证并发的原子性。
LongAdder是jdk8新增的用于并发环境的计数器，目的是为了在高并发情况下，代替AtomicLong/AtomicInt，成为一个用于高并发情况下的高效的通用计数器。
高并发下计数，一般最先想到的应该是AtomicLong/AtomicInt，AtmoicXXX使用硬件级别的指令 CAS 来更新计数器的值，这样可以避免加锁，机器直接支持的指令，效率也很高。但是AtomicXXX中的 CAS 操作在出现线程竞争时，失败的线程会白白地循环一次，在并发很大的情况下，因为每次CAS都只有一个线程能成功，竞争失败的线程会非常多。失败次数越多，循环次数就越多，很多线程的CAS操作越来越接近 自旋锁（spin lock）。计数操作本来是一个很简单的操作，实际需要耗费的cpu时间应该是越少越好，AtomicXXX在高并发计数时，大量的cpu时间都浪费会在 自旋 上了，这很浪费，也降低了实际的计数效率。
// jdk1.8的AtomicLong的实现代码，这段代码在sun.misc.Unsafe中 // 当线程竞争很激烈时，while判断条件中的CAS会连续多次返回false，这样就会造成无用的循环，循环中读取volatile变量的开销本来就是比较高的 // 因为这样，在高并发时，AtomicXXX并不是那么理想的计数方式 public final long getAndAddLong(Object o, long offset, long delta) { long v; do { v = getLongVolatile(o, offset); } while (!compareAndSwapLong(o, offset, v, v + delta)); return v; }
说LongAdder比在高并发时比AtomicLong更高效，这么说有什么依据呢？LongAdder是根据ConcurrentHashMap这类为并发设计的类的基本原理——锁分段，来实现的，它里面维护一组按需分配的计数单元，并发计数时，不同的线程可以在不同的计数单元上进行计数，这样减少了线程竞争，提高了并发效率。本质上是用空间换时间的思想，不过在实际高并发情况中消耗的空间可以忽略不计。
现在，在处理高并发计数时，应该优先使用LongAdder，而不是继续使用AtomicLong。当然，线程竞争很低的情况下进行计数，使用Atomic还是更简单更直接，并且效率稍微高一些。
既要看单线程的执行结果，还要看多线程对他的影响。
每次操作时候都要看局部变量是不是等于成员变量（判断是否没有别的线程干扰），最后再把局部变量赋值给成员变量完成修改。成员变量的修改都是CAS。
@SuppressWarnings("serial")
abstract class Striped641 extends Number1 {
static final int NCPU = Runtime.getRuntime().availableProcessors();
transient volatile Cell[] cells;// cell数组，长度一样要是2^n，可以类比为jdk1.7的ConcurrentHashMap中的segments数组
// 累积器的基本值 ，没有遇到并发的情况，直接使用base，速度更快；
transient volatile long base;//cas更新
// 自旋标识，在对cells进行初始化，或者后续扩容时，需要通过CAS操作把此标识设置为1（busy，忙标识，相当于加锁）， 取消busy时可以直接使用cellsBusy = 0，相当于释放锁
transient volatile int cellsBusy;//旋转锁
Striped641() {
}
final boolean casBase(long cmp, long val) {//原子更新base
return UNSAFE.compareAndSwapLong(this, BASE, cmp, val);
}
// 使用CAS将cells自旋标识更新为1，更新为0时可以不用CAS（赋值为0肯定是只有一个线程在赋值为0），直接使用cellsBusy就行
final boolean casCellsBusy() {//原子更新cellsBusy从0到1，以获取锁。
return UNSAFE.compareAndSwapInt(this, CELLSBUSY, 0, 1);
}
// 下面这两个方法是ThreadLocalRandom中的方法，不过因为包访问关系，这里又重新写一遍
// probe翻译过来是探测/探测器/探针这些，不好理解，它是ThreadLocalRandom里面的一个属性，
// 不过并不影响对Striped64的理解，这里可以把它理解为线程本身的hash值
static final int getProbe() {
return UNSAFE.getInt(Thread.currentThread(), PROBE);
}
// 相当于rehash，重新算一遍线程的hash值
static final int advanceProbe(int probe) {
probe ^= probe << 13; // xorshift
probe ^= probe >>> 17;
probe ^= probe << 5;
UNSAFE.putInt(Thread.currentThread(), PROBE, probe);//CAS设置当前线程的threadLocalRandomProbe
return probe;
}
//x：要增加的数。fn：执行函数。uncontended=false表示更新失败了，=true表示没有这个线程的Cell(不可能是更新成功了，更新成功就进不来这里)。
final void longAccumulate(long x, LongBinaryOperator fn, boolean wasUncontended) {//开始分段更新：1.base更新失败。2.前面分段更新不行或失败。
//新建，更新，扩容，初始化，更新base。
int h;//线程hash值
// 看下ThreadLocalRandom是否初始化。如果当前线程的threadLocalRandomProbe为0，说明当前线程是第一次进入该方法，
if ((h = getProbe()) == 0) {// 当前线程hash值=0，
ThreadLocalRandom.current(); //初始化当前线程的PROBE值不为0，
h = getProbe();
wasUncontended = true;//下面的cas语句走不走，还是间隔一个for循环在cas uncontended=false代表存在争用，uncontended=true代表不存在争用。
}
boolean collide = false; //下面的扩容语句走不走，还是间隔一个for循环在扩容 。collide=true代表cas有冲突，collide=false代表cas无冲突
for (;;) {
Cell[] as;//局部变量，线程执行时候，局部变量不会变，成员变量会改变（修改属性地址不变，重新new地址才改变）。as一进来就赋值后面没有更改过。
Cell a;//线程对应的cell，a一进来就赋值后面没有更改过。
//cellsBusy没有局部变量，直接使用成员变量。是一个锁。
int n;
long v;
//------------------------------------------重要---多线程时候，在一个线程的周期里面，前一个指令的判断（被另一个线程修改）现在不一定成立了-----------------------------------------------------//
/*每次执行真正操作时候，有可能刚才判断的条件全部不成立了，就要重来，那么刚才判断条件有什么用：不冲突有用。
执行成功时候：在锁住期间，刚才进来的判断都成立，近似于单线程操作，或者别的操作了，但是不影响现在要操作的条件。*/
/*多线程同时判断3个if，有可能一个线程判断第一个if不成立，但是判断第二个if时候，第一个if条件又成立了。走到后面的判断，只能说刚才前面的判断不成立，现在前面的判断不一定不成立了。
所以进入一个if：要看2个判断，之前判断是什么，现在判断是什么，才进入这个if条件 */
/*casCellsBusy()用于锁住这个cells，别的线程不能扩容和初始化和新建cell（但是可以cas更新存在的cell）。但是casCellsBusy()前后的条件不一定再次成立了，所以锁住之后要再次判断刚才的条件
，多线程时候上一次的判断现在不一定成立了。*/
/*局部变量，线程执行时候，局部变量不会变，成员变量会改变（修改属性地址不变，重新new地址才改变）。as一进来就赋值后面没有更改过。*/
/*在一个线程里面：1.已经有cells，要么新建（新建时候看是不是空），要么更新（要看是不是原值），要么扩容（要看cells有没有变化）。2.没有cells就去初始化（初始话时候再看是不是空）。3.初始化抢不赢就去更新base。*/
//------------------------------------------重要-----多线程时候，在一个线程的判断周期里面，前一个指令的判断（被另一个线程修改）现在不一定成立了---------------------------------------------------//
//as == cells,只有初始化和扩容（因为重新new）才不相等，修改值还是相等的。
//每次重新来，都会重新获取as和a，as = cells，a = as[(n - 1) & h]，并且更新线程hash。
// 1.已经有分段更新了cells！=null
if ((as = cells) != null && (n = as.length) > 0) {
//1.1 没有这个线程的Cell，新建
//重新来：1.新建cell时候有人占用cell。2.新建cell时候位置不为空。
if ((a = as[(n - 1) & h]) == null) {
if (cellsBusy == 0) { // cellsBusy=1表示有人在修改Cells数组（修改Cell从null到new Cell，扩容，初始化），CAS更新一个已经存在的Cell不用判断cellsBusy。
Cell r = new Cell(x); //这期间其他线程可以做很多事
if (cellsBusy == 0 && casCellsBusy()) {// cellsBusy是0就进来，然后变成cellsBusy=1，别的进不来。
//不可能多个线程同时进这里面来。
/*锁住cells，但是前面判断a=null，现在不一定a=null了，因为在前面判断到锁住cells期间cells有可能改变了，并且cellsBusy从0变到1又变到0。所以锁住之后在判断是不是空。*/
/*每次执行真正操作时候，有可能刚才判断的条件全部不成立了，就要重来，那么刚才判断条件有什么用：不冲突有用。
执行成功时候：在锁住期间，刚才进来的判断都成立，近似于单线程操作，或者别的操作了，但是不影响现在要操作的条件。*/
boolean created = false;
try {
Cell[] rs;
int m, j;
// 再次判断没有这个cell， 前面if判断了是空，走到这里时候有可能别人放进去了并且cellsBusy从0变到1再变到0了。如果不是null了，就不放，下次再来（直接更新）。
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;// cell不存在，但是有人修改cells，collide = false，
}
//1.2有这个线程的cell
//wasUncontended=false重新来
else if (!wasUncontended) // wasUncontended=false表示更新失败了，再来，wasUncontended=true下次不进这里直接去cas更新，否则先不cas先再来一次。
wasUncontended = true;
// 1.3有这个线程的cell
//wasUncontended=true,更新失败了重新来。
else if (a.cas(v = a.value, ((fn == null) ? v + x : fn.applyAsLong(v, x))))//这个线程有Cell,去更新。
break;// 更新成功，退出。
// 1.4有这个线程的cell
//wasUncontended=true,更新失败，cells初始化扩容了，重新来
else if (n >= NCPU || cells != as) // CPU能够并行的CAS操作的最大数量是它的核心数 ，cells被改变了（扩容了肯定重新来）。
collide = false;
// 1.5有这个线程的cell
//wasUncontended=true,更新失败，cells没有初始化扩容，collide=false，重新来
else if (!collide) //=false走这里，collide=true，下次不走这里直接去扩容否则先不去扩容先再来一次。
collide = true;
// 1.6有这个线程的cell
//wasUncontended=true,更新失败，cells没有初始化扩容，collide=true，占用cells，扩容完成，重新来
//有这个线程的cell,cas失败，说明2个线程同时更新这个cell，就扩容。既然你不让我加，竞争这么厉害，那么扩容试试看。
else if (cellsBusy == 0 && /* 这期间其他线程可以做很多事 */casCellsBusy()) {
//不可能多个线程同时进这里面来。
try {
if (cells == as) { //锁住cells了，最开始as = cells，但是现在as不一定=cells，所以判断cells没变扩容，
Cell[] rs = new Cell[n << 1];// 执行2倍扩容
for (int i = 0; i < n; ++i)
rs[i] = as[i];
cells = rs;
}
} finally {
cellsBusy = 0;// 释放锁
}
collide = false;// 扩容意向为false
continue; // 扩容后还没有设置值（肯定重新来）
}
//1.7 有这个线程的cell
h = advanceProbe(h);// 修改当前线程的hash，降低hash冲突（线程hash改变是无所谓的，关注的是里面的值，与哪个线程放进去无关），避免下次还映射到这个cell。
}
// 2。某个线程执行时候，前一个if判断：没有分段更新，cells==null或者cells.length=0。走到这里时候cells有可能不为空了，但是要进入这if必须：cellsBusy=0，
//同时cells还是刚才那个as=null（没有扩容和初始化）并且casCellsBusy()抢成功，就去初始化。
//线程执行到这里：之前判断：【没有cells】，并且现在【没人扩容或者初始化，并且cells为空】就初始化。
else if (cellsBusy == 0 && cells == as && /*这期间其他线程可以做很多事*/casCellsBusy()) {// cellsBusy=1，别的线程就不能动cells
//不可能多个线程同时进这里面来。
boolean init = false;
try {
if (cells == as) { //锁住cells了，但是cells不一定=as=空或者null了， 锁住之后一定要再检测一次，如果还是null就初始化
Cell[] rs = new Cell[2];// 初始化时只创建两个单元
rs[h & 1] = new Cell(x);// 对其中一个单元进行累积操作，另一个不管，继续为null
cells = rs;
init = true;
}
} finally {
cellsBusy = 0;// 释放锁
}
if (init)// 初始化成功退出，初始化失败继续来
break;
}
// 3。走到这里：前面判断不成立（不代表现在的前面判断也不成立），之前判断：cells=null或者cells.length=0【没有cells】并且cellsBusy=1或者 cells被改变了【有人正在初始化或扩容】或者casCellsBusy()失败。
//有了分段更新，还是可以用base，提高效率。准备去扩容的，但是现在有可能别人已经扩容了（cells ！= as）或者casCellsBusy()失败（抢着去扩容没有抢成功）
else if (casBase(v = base, ((fn == null) ? v + x : fn.applyAsLong(v, x))))
break; // 更新base，成功就退出。
}
/*如果Cells表为空，尝试获取锁之后初始化表（初始大小为2）；
如果Cells表非空，对应的Cell为空，自旋锁未被占用，尝试获取锁，添加新的Cell；
如果Cells表非空，找到线程对应的Cell，尝试通过CAS更新该值；
如果Cells表非空，线程对应的Cell CAS更新失败，说明存在竞争，尝试获取自旋锁之后扩容,将cells数组扩大，降低每个cell的并发量后再试*/
}
// double更long的逻辑基本上是一样的
final void doubleAccumulate(double x, DoubleBinaryOperator fn, boolean wasUncontended) {
int h;
if ((h = getProbe()) == 0) {
ThreadLocalRandom.current(); // force initialization
h = getProbe();
wasUncontended = true;
}
boolean collide = false; // True if last slot nonempty
for (;;) {
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) { // Try to attach new Cell
Cell r = new Cell(Double.doubleToRawLongBits(x));
if (cellsBusy == 0 && casCellsBusy()) {
boolean created = false;
try { // Recheck under lock
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; // Slot is now non-empty
}
}
collide = false;
} else if (!wasUncontended) // CAS already known to fail
wasUncontended = true; // Continue after rehash
else if (a.cas(v = a.value, ((fn == null) ? Double.doubleToRawLongBits(Double.longBitsToDouble(v) + x)
: Double.doubleToRawLongBits(fn.applyAsDouble(Double.longBitsToDouble(v), x)))))
break;
else if (n >= NCPU || cells != as)
collide = false; // At max size or stale
else if (!collide)
collide = true;
else if (cellsBusy == 0 && casCellsBusy()) {
try {
if (cells == as) { // Expand table unless stale
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; // Retry with expanded table
}
h = advanceProbe(h);
} else if (cellsBusy == 0 && cells == as && casCellsBusy()) {
boolean init = false;
try { // Initialize table
if (cells == as) {
Cell[] rs = new Cell[2];
rs[h & 1] = new Cell(Double.doubleToRawLongBits(x));
cells = rs;
init = true;
}
} finally {
cellsBusy = 0;
}
if (init)
break;
} else if (casBase(v = base, ((fn == null) ? Double.doubleToRawLongBits(Double.longBitsToDouble(v) + x)
: Double.doubleToRawLongBits(fn.applyAsDouble(Double.longBitsToDouble(v), x)))))
break; // Fall back on using base
}
}
private static final sun.misc.Unsafe UNSAFE;
private static final long BASE;
private static final long CELLSBUSY;
private static final long PROBE;
static {
try {
UNSAFE = sun.misc.Unsafe.getUnsafe();
Class<?> sk = Striped641.class;
BASE = UNSAFE.objectFieldOffset(sk.getDeclaredField("base"));
CELLSBUSY = UNSAFE.objectFieldOffset(sk.getDeclaredField("cellsBusy"));
Class<?> tk = Thread.class;
PROBE = UNSAFE.objectFieldOffset(tk.getDeclaredField("threadLocalRandomProbe"));
} catch (Exception e) {
throw new Error(e);
}
}
// 一个Cell里面一个value，可以看成是一个简化的AtomicLong，通过cas操作来更新value的值
// @sun.misc.Contended是一个高端的注解，代表使用缓存行填来避免伪共享
@sun.misc.Contended
static final class Cell {
volatile long value;// cas更新其值
Cell(long x) {
value = x;
}
final boolean cas(long cmp, long val) {// cas更新
return UNSAFE.compareAndSwapLong(this, valueOffset, cmp, val);
}
private static final sun.misc.Unsafe UNSAFE;
private static final long valueOffset;
static {
try {
UNSAFE = sun.misc.Unsafe.getUnsafe();
Class<?> ak = Cell.class;
valueOffset = UNSAFE.objectFieldOffset(ak.getDeclaredField("value"));
} catch (Exception e) {
throw new Error(e);
}
}
}
}
public class LongAdder1 extends Striped641 implements Serializable { private static final long serialVersionUID = 7249069246863182397L; public LongAdder1() { } /*看到这里我想应该有很多人明白为什么LongAdder会比AtomicLong更高效了， 没错，唯一会制约AtomicLong高效的原因是高并发，高并发意味着CAS的失败几率更高， 重试次数更多，越多线程重试，CAS失败几率又越高，变成恶性循环，AtomicLong效率降低。 那怎么解决？** LongAdder给了我们一个非常容易想到的解决方案：减少并发，将单一value的更新压力分担到多个value中去 （每个线程更新value数组里面的自己value【多个线程访问的同一个数组（也只有一个数组）但是cas更新的是只是其中一个value】 【因为数组有限，所以不同的线程也会出现同时cas更新一个value的情况】【会出现：多个线程同时访问这个数组的同一个cell】， 不再是多个线程更新同一个value导致cas经常失败）， 降低单个value的 “热度”，分段更新 */ /*这样，线程数再多也会分担到多个value上去更新，只需要增加value就可以降低 value的 “热度” AtomicLong中的 恶性循环不就解决了吗？ cells 就是这个 “段” cell中的value 就是存放更新值的， 这样，当我需要总数时，把cells 中的value都累加一下不就可以了么！！*/ /*当然，聪明之处远远不仅仅这里，在看看add方法中的代码，casBase方法可不可以不要，直接分段更新,上来就计算 索引位置，然后更新value？ 答案是不好，不是不行，因为，casBase操作等价于AtomicLong中的CAS操作，要知道，LongAdder这样的处理方式是有坏处的， 分段操作必然带来空间上的浪费，可以空间换时间，但是，能不换就不换，看空间时间都节约~！ 所以，casBase操作保证了在低并发时，不会立即进入分支做分段更新操作，因为低并发时， casBase操作基本都会成功，只有并发高到一定程度了，才会进入分支， 所以，Doug Lea对该类的说明是：** 低并发时LongAdder和AtomicLong性能差不多，高并发时LongAdder更高效！***/ /*因为低并发时候，使用的是base的原子更新，没有启用分段更新（cells=null，并且casBase成功），高并发才启用分段更新。*/ /*如此，longAccumulate中做了什么事，也基本略知一二了，因为cell中的value都更新失败(说明该索引到这个cell的线程也很多 ，并发也很高时) 或者cells数组为空时才会调用longAccumulate,*/ // +x，并发计数器LongAdder加X。要么在base+x更新要么在Cell[]数组里面找到对应的Cell+x更新。 public void add(long x) {//base和cells只有一个，并且是LongAdder的属性。 Cell[] as; long b, v; int m; Cell a; //cells!=null不用判断后面进去（表明已经启用了分段更新），cells=null并且base的cas更新失败进去（表示没有启用分段更新但是高并发了， //需要启用分段更新），cells=null并且base的cas更新成功就退出（没有启用分段更新，并且不是高并发，此时跟AotomicLong是一样的）。 //并发时候更新失败，AtomicLong的处理方式是死循环尝试更新，直到成功才返回，而LongAdder则是进入这个分支。 if ((as = cells) != null || !casBase(b = base, b + x)/*cas把base的值从b变成b+x*/) { //进来：1.已经启用分段更新了。2.没有启用分段更新但是cas失败了表示高并发了。否则：没有启用分段更新并且不是高并发，就不进来。 boolean uncontended = true; if (as == null //cells=null进去，没有启用分段更新（进来了）表示高并发了。 || (m = as.length - 1) < 0 //cells.length<=0，没有启用分段更新（进来了）表示高并发了。 || (a = as[getProbe() & m]) == null //对as的长度取余，从as中获取这个线程对应的a Cell。=null表示还没有这个线程对应的cell， || !(uncontended = a.cas(v = a.value, v + x))) //a这个Cell里面的value增加x失败， 更新成功就不会进下面了。 //1.cells=null。2.cells!=null但没有这个线程的Cell。2.有这个线程的Cell但是更新失败了。 longAccumulate(x, null, uncontended); //uncontended=false表示更新失败了，=true表示没有这个线程的Cell(不可能是更新成功了，更新成功就进不来这里)。 } } public void increment() { add(1L); } public void decrement() { add(-1L); } //将多个cell数组中的值加起来的和就类似于AtomicLong中的value // 此返回值可能不是绝对准确的，因为调用这个方法时还有其他线程可能正在进行计数累加， // 方法的返回时刻和调用时刻不是同一个点，在有并发的情况下，这个值只是近似准确的计数值 // 高并发时，除非全局加锁，否则得不到程序运行中某个时刻绝对准确的值，但是全局加锁在高并发情况下是下下策 // 在很多的并发场景中，计数操作并不是核心，这种情况下允许计数器的值出现一点偏差，此时可以使用LongAdder // 在必须依赖准确计数值的场景中，应该自己处理而不是使用通用的类。 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; } public void reset() { Cell[] as = cells; Cell a; base = 0L; if (as != null) { for (int i = 0; i < as.length; ++i) { if ((a = as[i]) != null) a.value = 0L; } } } public long sumThenReset() { Cell[] as = cells; Cell a; long sum = base; base = 0L; if (as != null) { for (int i = 0; i < as.length; ++i) { if ((a = as[i]) != null) { sum += a.value; a.value = 0L; } } } return sum; } public String toString() { return Long.toString(sum()); } public long longValue() { return sum(); } public int intValue() { return (int) sum(); } public float floatValue() { return (float) sum(); } public double doubleValue() { return (double) sum(); } private static class SerializationProxy implements Serializable { private static final long serialVersionUID = 7249069246863182397L; private final long value;//LongAdder1的总和 SerializationProxy(LongAdder1 a) { value = a.sum(); } private Object readResolve() { LongAdder1 a = new LongAdder1(); a.base = value; return a; } } private Object writeReplace() { return new SerializationProxy(this); } private void readObject(java.io.ObjectInputStream s) throws java.io.InvalidObjectException { throw new java.io.InvalidObjectException("Proxy required"); } }
public abstract class Number1 implements java.io.Serializable { public abstract int intValue(); public abstract long longValue(); public abstract float floatValue(); public abstract double doubleValue(); /* System.out.println((byte)127);//127 System.out.println((byte)128);//-128 System.out.println((byte)129);//-127 System.out.println((byte)255);//-1 System.out.println((byte)256);//0 System.out.println((byte)257);//1 */ public byte byteValue() { return (byte) intValue(); } public short shortValue() { return (short) intValue(); } private static final long serialVersionUID = -8742448824652078965L; }
