AtomicInteger源码分析
2017-07-31 11:39
134 查看
CAS
CAS(Compare-And-Swap，比较并交换)操作是CPU中术语，它保证了操作的原子性。CAS指令需要三个操作数，分别是：
Ｖ：内存位置（也就是本次操作变量的内存地址）；
Ａ：旧的预期值；
Ｂ： 操作完成后的新值。
CAS指令执行时，当且仅当V符合旧预期值A时，处理器用新值B更新V的值，否则它就不执行更新，无论是否更新，都会返回V的旧值，整个CAS操作是一个原子操作。在JDK1.5之后，Java程序中才可以使用CAS操作，该操作由sun.misc.Unsafe类里的compareAndSwapXXX()方法包装提供，虚拟机在内部对这些方法做了特殊处理。在JDK1.5中提供了原子变量，如AtomicInteger,AtomicLong等，由并发大师Doug
Lea操刀，提供了在单个变量上面不需要锁的线程安全性。现在就让我们走进AtomicInteger的世界中，探究它是如何实现的，并领略大师的风采。
AtomicInteger中原子操作的实现
通过这一小部分的分析，我们就弄明白了AtomicInteger中原子操作的实现，首先看看AtomicInteger中有哪些状态
[java] view
plain copy
public class AtomicInteger extends Number implements java.io.Serializable {
private static final long serialVersionUID = 6214790243416807050L;
//使用Unsafe.compareAndSwapInt来执行修改操作，CAS是通过Unsafe.compareAndSwapXXX()方法实现的
private static final Unsafe unsafe = Unsafe.getUnsafe();
//value在内存中的地址偏移量
private static final long valueOffset;
static {
try {
//获得value的内存地址偏移量
valueOffset = unsafe.objectFieldOffset
(AtomicInteger.class.getDeclaredField("value"));
} catch (Exception ex) { throw new Error(ex); }
}
//当前对象代表的值，注意是volatile
private volatile int value;
在这一段代码中，我们需要注意三个方面，也就是AtomicInteger的三个字段：
（1）unsafe字段，AtomicInteger包含了一个Unsafe类的实例，unsafe就是用来实现CAS的；
（2）value字段，表示当前对象代码的基本类型的值，AtomicInteger是int型的线程安全包装类，value就代码了AtomicInteger的值。注意，这个字段是volatile的。
（3）valueOfset，通过字面意思就可以看出来valueOfset是value在内存中的偏移量，也就是在内存中的地址，通过Unsafe.objectFieldOffset(Field f)获取。前面在讲CAS时，我们提到需要操作内存的位置，valueOfset就是这个位置。
AtomicInteger中的CAS
public final boolean compareAndSet(int expect,int update)就是CAS的具体实现，其他所有的原子操作都是依赖于此方法，前面已经提到了，Java中的CAS是通过Unsafe类实现的，这个方法就是通过调用Unsafe.compareAndSwapInt(this,valueOfset,expect,udate)方法来实现的，其中valueOffset就是要操作的内存地址，expect是旧值，update是新值，当且仅当valueOffset内存中的值等于expect时，才用update更新旧值。其代码如下：
[java] view
plain copy
/**
* 原子操作
* CAS:Compare-and-Swap
* 如果当前值==expect，则设置新值
*/
public final boolean compareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
AtomicInteger提供了好几个原子操作变量的方法：
可以看到，每一种操作（自增，自减，加给定值）都提供了对称的操作，其中getAndXXX()方法是返回旧值，XXXAndGet()返回的是新值。这些操作的实现方式都是相同的，我们以getAndIncrement()为例，来讲解它是如何实现原子操作的。首先看getAndIncrement()的源码：
[java] view
plain copy
/**
* 原子操作，实现自增操作，通过CAS实现，返回自增之前的值
* 实现原理是这样的：
* 1.首先获得当前值，保存到current中，next=current + 1
* 2.如果CAS成功，则返回current
* 如果CAS不成功，这说明刚刚有其他的线程修改了当前值，current已经失效了，next也已经失效了
* 只能重新获取当值，并继续CAS，直到成功为止
*/
public final int getAndIncrement() {
for (;;) {
int current = get();
int next = current + 1;
if (compareAndSet(current, next))
return current;
}
}
在上面的注释中已经说的比较明白了，但我还是愿意再啰嗦两句：
（1）首先获得当前值，保存到current中，并把current的下一个值保存到next中，next=current+1
（2）调用compareAndSet(current,next)尝试自增，如果自增成功，则返回current；如果自增失败，则说明已经有其他线程修改value的值，current中的值和next中的值已经失效了，要重新获取当前值，重复刚才的CAS操作，直到成功位置。
可以看到，通过第（2）步的操作，确实实现了多线程下的安全，即使在自增的时候有其他线程修改了当前值，自增操作也不会覆盖已经修改的值，而是在当前最新值的基础上实现自增。演示一下不使用CAS的错误情况和这种实现方式的正确性
a.错误的自增，假设当前value=8，同时有两个线程t1,t2对value执行自增操作，执行顺序如下：
执行完成后，t2的值把t1的值给覆盖了，执行完成后，现在value=9，正确的结果应该是10。在下图中，通过CAS以同样的顺序执行，获得的结果就是正确的：
上面的分析基本上就概括了AtomicInteger实现的全部了。但是CAS并不是没有缺点，概括起来说，CAS就三个缺点：
（1）ABA问题，如果V的初始值是A，在准备赋值的时候检查到它仍然是A，那么能说它没有改变过吗？也许V经历了这样一个过程：它先变成了B，又变成了A，使用CAS检查时以为它没变，其实却变里；
（2）循环时间长，开销大，通过自旋CAS一直在消耗CPU
（3）只能保证一个共享变量的原子操作，当对多个共享变量操作时就无法保证原子性了。
AtomicInteger源码分析：
[java] view
plain copy
package com.java.source;
import sun.misc.Unsafe;
public class AtomicInteger extends Number implements java.io.Serializable {
private static final long serialVersionUID = 6214790243416807050L;
//使用Unsafe.compareAndSwapInt来执行修改操作，CAS是通过Unsafe.compareAndSwapXXX()方法实现的
private static final Unsafe unsafe = Unsafe.getUnsafe();
//value在内存中的地址偏移量
private static final long valueOffset;
static {
try {
//获得value的内存地址偏移量
valueOffset = unsafe.objectFieldOffset
(AtomicInteger.class.getDeclaredField("value"));
} catch (Exception ex) { throw new Error(ex); }
}
//当前对象代表的值，注意是volatile
private volatile int value;
/*使用给定的值创建对象，也就是把给定的值包装起来*/
public AtomicInteger(int initialValue) {
value = initialValue;
}
/*默认初始化为0*/
public AtomicInteger() {
}
/*getter/setter*/
public final int get() {
return value;
}
public final void set(int newValue) {
value = newValue;
}
/*最后设置指定的值*/
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;
}
}
/**
* 原子操作
* CAS:Compare-and-Swap
* 如果当前值==expect，则设置新值
*/
public final boolean compareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
/**
* 原子操作，功能与compareAndSet一样
* 有可能意外失败，且不保证排序，但是调用的代码是完全一样的，JVM又在内部做了手脚？
* 在极少情况下用来替代compareAndSet
*/
public final boolean weakCompareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
/**
* 原子操作，实现自增操作，通过CAS实现，返回自增之前的值
* 实现原理是这样的：
* 1.首先获得当前值，保存到current中，next=current + 1
* 2.如果CAS成功，则返回current
* 如果CAS不成功，这说明刚刚有其他的线程修改了当前值，current已经失效了，next也已经失效了
* 只能重新获取当值，并继续CAS，直到成功为止
*/
public final int getAndIncrement() {
for (;;) {
int current = get();
int next = current + 1;
if (compareAndSet(current, next))
return current;
}
}
/**
* 原子操作，实现自减，通过CAS实现，返回当前值
* 实现方法同getAndIncrement()相同
*/
public final int getAndDecrement() {
for (;;) {
int current = get();
int next = current - 1;
if (compareAndSet(current, next))
return current;
}
}
/**
* 原子操作，将当前值增加delta，并返回当前值
* 实现原理同getAndIncrement()相同，只不过一个是增1，一个是增delta
*/
public final int getAndAdd(int delta) {
for (;;) {
int current = get();
int next = current + delta;
if (compareAndSet(current, next))
return current;
}
}
/*原子操作，自增一，并返回增加后的值*/
public final int incrementAndGet() {
for (;;) {
int current = get();
int next = current + 1;
if (compareAndSet(current, next))
return next;
}
}
/*原子操作，自减，并返回减小后的值*/
public final int decrementAndGet() {
for (;;) {
int current = get();
int next = current - 1;
if (compareAndSet(current, next))
return next;
}
}
/*原子操作，增加delta，并返回增加后的操作*/
public final int addAndGet(int delta) {
for (;;) {
int current = get();
int next = current + delta;
if (compareAndSet(current, next))
return next;
}
}
/**
* 一些常规方法
*/
public String toString() {
return Integer.toString(get());AtomicLong
}
public int intValue() {
return get();
}
public long longValue() {
return (long)get();
}
public float floatValue() {
return (float)get();
}
public double doubleValue() {
return (double)get();
}
}
转载出处：点击打开链接
举个例子：（原创）
public class bingfa {
public static void main(String[] args) {
RunTest task = new RunTest();
new Thread(task).start();
new Thread(task).start();
try {
Thread.sleep(3000);
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.println(task.count);
}
}
class RunTest implements Runnable{
//public int count; //输出结果不为2000
AtomicInteger count = new AtomicInteger(0); //输出结果为2000
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
//count++;
count.addAndGet(1);
}
}
}
CAS(Compare-And-Swap，比较并交换)操作是CPU中术语，它保证了操作的原子性。CAS指令需要三个操作数，分别是：
Ｖ：内存位置（也就是本次操作变量的内存地址）；
Ａ：旧的预期值；
Ｂ： 操作完成后的新值。
CAS指令执行时，当且仅当V符合旧预期值A时，处理器用新值B更新V的值，否则它就不执行更新，无论是否更新，都会返回V的旧值，整个CAS操作是一个原子操作。在JDK1.5之后，Java程序中才可以使用CAS操作，该操作由sun.misc.Unsafe类里的compareAndSwapXXX()方法包装提供，虚拟机在内部对这些方法做了特殊处理。在JDK1.5中提供了原子变量，如AtomicInteger,AtomicLong等，由并发大师Doug
Lea操刀，提供了在单个变量上面不需要锁的线程安全性。现在就让我们走进AtomicInteger的世界中，探究它是如何实现的，并领略大师的风采。
AtomicInteger中原子操作的实现
通过这一小部分的分析，我们就弄明白了AtomicInteger中原子操作的实现，首先看看AtomicInteger中有哪些状态
[java] view
plain copy
public class AtomicInteger extends Number implements java.io.Serializable {
private static final long serialVersionUID = 6214790243416807050L;
//使用Unsafe.compareAndSwapInt来执行修改操作，CAS是通过Unsafe.compareAndSwapXXX()方法实现的
private static final Unsafe unsafe = Unsafe.getUnsafe();
//value在内存中的地址偏移量
private static final long valueOffset;
static {
try {
//获得value的内存地址偏移量
valueOffset = unsafe.objectFieldOffset
(AtomicInteger.class.getDeclaredField("value"));
} catch (Exception ex) { throw new Error(ex); }
}
//当前对象代表的值，注意是volatile
private volatile int value;
在这一段代码中，我们需要注意三个方面，也就是AtomicInteger的三个字段：
（1）unsafe字段，AtomicInteger包含了一个Unsafe类的实例，unsafe就是用来实现CAS的；
（2）value字段，表示当前对象代码的基本类型的值，AtomicInteger是int型的线程安全包装类，value就代码了AtomicInteger的值。注意，这个字段是volatile的。
（3）valueOfset，通过字面意思就可以看出来valueOfset是value在内存中的偏移量，也就是在内存中的地址，通过Unsafe.objectFieldOffset(Field f)获取。前面在讲CAS时，我们提到需要操作内存的位置，valueOfset就是这个位置。
AtomicInteger中的CAS
public final boolean compareAndSet(int expect,int update)就是CAS的具体实现，其他所有的原子操作都是依赖于此方法，前面已经提到了，Java中的CAS是通过Unsafe类实现的，这个方法就是通过调用Unsafe.compareAndSwapInt(this,valueOfset,expect,udate)方法来实现的，其中valueOffset就是要操作的内存地址，expect是旧值，update是新值，当且仅当valueOffset内存中的值等于expect时，才用update更新旧值。其代码如下：
[java] view
plain copy
/**
* 原子操作
* CAS:Compare-and-Swap
* 如果当前值==expect，则设置新值
*/
public final boolean compareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
AtomicInteger提供了好几个原子操作变量的方法：
int | addAndGet(int delta) 将当前值与给定的值相加，并返回新值 |
boolean | compareAndSet(int expect, int update) 当且仅当value==expect，value=update |
int | decrementAndGet() 自减1，并返回新值 |
int | getAndAdd(int delta) 将当前值与给定值相加，并返回相加之前的值（旧值） |
int | getAndDecrement() 自减1，并返回旧值 |
int | getAndIncrement() 自增1，并返回旧值 |
int | getAndSet(int newValue) 将当前值与给定值相加，并返回旧值 |
int | incrementAndGet() 自增1，并返回新值 |
[java] view
plain copy
/**
* 原子操作，实现自增操作，通过CAS实现，返回自增之前的值
* 实现原理是这样的：
* 1.首先获得当前值，保存到current中，next=current + 1
* 2.如果CAS成功，则返回current
* 如果CAS不成功，这说明刚刚有其他的线程修改了当前值，current已经失效了，next也已经失效了
* 只能重新获取当值，并继续CAS，直到成功为止
*/
public final int getAndIncrement() {
for (;;) {
int current = get();
int next = current + 1;
if (compareAndSet(current, next))
return current;
}
}
在上面的注释中已经说的比较明白了，但我还是愿意再啰嗦两句：
（1）首先获得当前值，保存到current中，并把current的下一个值保存到next中，next=current+1
（2）调用compareAndSet(current,next)尝试自增，如果自增成功，则返回current；如果自增失败，则说明已经有其他线程修改value的值，current中的值和next中的值已经失效了，要重新获取当前值，重复刚才的CAS操作，直到成功位置。
可以看到，通过第（2）步的操作，确实实现了多线程下的安全，即使在自增的时候有其他线程修改了当前值，自增操作也不会覆盖已经修改的值，而是在当前最新值的基础上实现自增。演示一下不使用CAS的错误情况和这种实现方式的正确性
a.错误的自增，假设当前value=8，同时有两个线程t1,t2对value执行自增操作，执行顺序如下：
执行完成后，t2的值把t1的值给覆盖了，执行完成后，现在value=9，正确的结果应该是10。在下图中，通过CAS以同样的顺序执行，获得的结果就是正确的：
上面的分析基本上就概括了AtomicInteger实现的全部了。但是CAS并不是没有缺点，概括起来说，CAS就三个缺点：
（1）ABA问题，如果V的初始值是A，在准备赋值的时候检查到它仍然是A，那么能说它没有改变过吗？也许V经历了这样一个过程：它先变成了B，又变成了A，使用CAS检查时以为它没变，其实却变里；
（2）循环时间长，开销大，通过自旋CAS一直在消耗CPU
（3）只能保证一个共享变量的原子操作，当对多个共享变量操作时就无法保证原子性了。
AtomicInteger源码分析：
[java] view
plain copy
package com.java.source;
import sun.misc.Unsafe;
public class AtomicInteger extends Number implements java.io.Serializable {
private static final long serialVersionUID = 6214790243416807050L;
//使用Unsafe.compareAndSwapInt来执行修改操作，CAS是通过Unsafe.compareAndSwapXXX()方法实现的
private static final Unsafe unsafe = Unsafe.getUnsafe();
//value在内存中的地址偏移量
private static final long valueOffset;
static {
try {
//获得value的内存地址偏移量
valueOffset = unsafe.objectFieldOffset
(AtomicInteger.class.getDeclaredField("value"));
} catch (Exception ex) { throw new Error(ex); }
}
//当前对象代表的值，注意是volatile
private volatile int value;
/*使用给定的值创建对象，也就是把给定的值包装起来*/
public AtomicInteger(int initialValue) {
value = initialValue;
}
/*默认初始化为0*/
public AtomicInteger() {
}
/*getter/setter*/
public final int get() {
return value;
}
public final void set(int newValue) {
value = newValue;
}
/*最后设置指定的值*/
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;
}
}
/**
* 原子操作
* CAS:Compare-and-Swap
* 如果当前值==expect，则设置新值
*/
public final boolean compareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
/**
* 原子操作，功能与compareAndSet一样
* 有可能意外失败，且不保证排序，但是调用的代码是完全一样的，JVM又在内部做了手脚？
* 在极少情况下用来替代compareAndSet
*/
public final boolean weakCompareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
/**
* 原子操作，实现自增操作，通过CAS实现，返回自增之前的值
* 实现原理是这样的：
* 1.首先获得当前值，保存到current中，next=current + 1
* 2.如果CAS成功，则返回current
* 如果CAS不成功，这说明刚刚有其他的线程修改了当前值，current已经失效了，next也已经失效了
* 只能重新获取当值，并继续CAS，直到成功为止
*/
public final int getAndIncrement() {
for (;;) {
int current = get();
int next = current + 1;
if (compareAndSet(current, next))
return current;
}
}
/**
* 原子操作，实现自减，通过CAS实现，返回当前值
* 实现方法同getAndIncrement()相同
*/
public final int getAndDecrement() {
for (;;) {
int current = get();
int next = current - 1;
if (compareAndSet(current, next))
return current;
}
}
/**
* 原子操作，将当前值增加delta，并返回当前值
* 实现原理同getAndIncrement()相同，只不过一个是增1，一个是增delta
*/
public final int getAndAdd(int delta) {
for (;;) {
int current = get();
int next = current + delta;
if (compareAndSet(current, next))
return current;
}
}
/*原子操作，自增一，并返回增加后的值*/
public final int incrementAndGet() {
for (;;) {
int current = get();
int next = current + 1;
if (compareAndSet(current, next))
return next;
}
}
/*原子操作，自减，并返回减小后的值*/
public final int decrementAndGet() {
for (;;) {
int current = get();
int next = current - 1;
if (compareAndSet(current, next))
return next;
}
}
/*原子操作，增加delta，并返回增加后的操作*/
public final int addAndGet(int delta) {
for (;;) {
int current = get();
int next = current + delta;
if (compareAndSet(current, next))
return next;
}
}
/**
* 一些常规方法
*/
public String toString() {
return Integer.toString(get());AtomicLong
}
public int intValue() {
return get();
}
public long longValue() {
return (long)get();
}
public float floatValue() {
return (float)get();
}
public double doubleValue() {
return (double)get();
}
}
转载出处：点击打开链接
举个例子：（原创）
public class bingfa {
public static void main(String[] args) {
RunTest task = new RunTest();
new Thread(task).start();
new Thread(task).start();
try {
Thread.sleep(3000);
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.println(task.count);
}
}
class RunTest implements Runnable{
//public int count; //输出结果不为2000
AtomicInteger count = new AtomicInteger(0); //输出结果为2000
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
//count++;
count.addAndGet(1);
}
}
}
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- AtomicInteger源码分析——基于CAS的乐观锁实现
- AtomicInteger源码分析
- AtomicInteger源码分析
- 从虚断，虚短分析基本运放电路
- 架构分析设计在面向对象系统分析和设计中的作用
- Oracle分析函数参考手册
- hadoop集群System Cpu消耗过高问题分析--内存碎片整合问题
- Campus Guider校园导航系统 Hash算法分析
- 【漏洞分析】MS17-010：深入分析“永恒之蓝”漏洞
- HashMap，ArrayMap，SparseArray源码分析及性能对比
- STL源码分析之vector(一) 基本数据类型及构造函数
- 南邮算法分析与设计实验4 密码算法
- hdfs源码分析第一弹
- 【自然语言处理】利用nltk实现情感分析
- ogre 阴影技术分析记录
- 【您还有心跳吗？超时机制分析 】
- Weka算法Classifier-tree-J48源码分析（一）算法和基本数据结构
- 德国VS西班牙 假球分析