1 Atomic原子类概述
JDK1.5开始出现
1.1 Atomic原子类分类
- 1 原子更新基本类型
- 2 原子更新数组
- 3 原子更新抽象类型
- 4 原子更新字段
1.2 Atomic原子类所在位置
2.Atomic原子类代码演示
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicIntegerArray;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
import java.util.concurrent.atomic.AtomicReference;
public class AtomicSequence {
private static boolean test1Flag = false;
private static boolean test2Flag = false;
private static boolean test3Flag = true;
private static boolean test4Flag = false;
//1.原子更新基本类型 -- Integer的原子类,
private AtomicInteger atomicIntegerValue = new AtomicInteger(0);
//1.1 没有char类的原子性,转换成char的unicode码后用integer来实现
//2.原子更新数组
private int [] integerArray = {1,2,10,5};
AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(integerArray);
//3.原子更新抽象类型,对用户进行原子操作,是对用户里面的属性进行原子操作
AtomicReference<User> atomicReferenceUser = new AtomicReference<>();
User userTemp = new User();
//4.原子更新字段-对象的属性字段
AtomicIntegerFieldUpdater<User> atomicIntegerFieldUpdaterUserAge = AtomicIntegerFieldUpdater.newUpdater(User.class, "age");
//1.AtomicInteger
public int getNextAtomicInteger() {
Integer value1 = atomicIntegerValue.getAndIncrement(); //返回并递增
Integer value2 = atomicIntegerValue.incrementAndGet(); //递增并返回
Integer value3 = atomicIntegerValue.getAndDecrement(); //返回并递减
Integer value4 = atomicIntegerValue.getAndAdd(10); //递增+10
return value1; //返回并递增
}
//1-2.AtomicInteger-->String
public void getNextAtomicIntegerString(){
System.out.println("atomicIntegerValue.toString()->"+atomicIntegerArray.toString());
}
//2.数组
public Integer getNextAtomicIntegerArray() {
Integer value1 = atomicIntegerArray.getAndIncrement(0); //指定位置增加值1(从0开始)
Integer value2 = atomicIntegerArray.getAndAdd(2, 10);//指定位置增加指定值
Integer value3 = atomicIntegerArray.addAndGet(3,5);//指定位置添加并获取
return value1;
}
//3.原子更新抽象类型属性,
public Integer getNextAtomicIntegerFieldUpdater() {
Integer userAge = atomicIntegerFieldUpdaterUserAge.getAndIncrement(userTemp);
System.out.println("userage->"+userAge);
return userAge;
}
public static void main(String[] args) {
AtomicSequence atomicSequence = new AtomicSequence();
new Thread(new Runnable() {
//atomicSequence.getNextAtomicInteger()可以演示多线程,然后会发现线程安全
@Override
public void run() {
for(int i =0;i<20;i++) {
if(test1Flag) {
//1-1.获取原子更新基本类型线程1
System.out.println(Thread.currentThread().getName() + "原子Integer结果为-:" + atomicSequence.getNextAtomicInteger());
}
if(test2Flag) {
//2-1.获取原子更新数组类型线程1
System.out.println(Thread.currentThread().getName() + "原子数组类型结果为--:" + atomicSequence.getNextAtomicIntegerArray());
}
if(test3Flag) {
//3-1.获取原子引用类型属性值线程1
System.out.println(Thread.currentThread().getName() + "原子引用类型属性值结果为---:" + atomicSequence.getNextAtomicIntegerFieldUpdater());
}
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
for(int i =0;i<20;i++) {
if(test1Flag) {
//1-2获取原子更新基本类型线程2
System.out.println(Thread.currentThread().getName() + "原子Integer结果为-:" + atomicSequence.getNextAtomicInteger());
}
if(test2Flag) {
//2-2.获取原子更新数组类型线程2
System.out.println(Thread.currentThread().getName() + "原子数组类型结果为--:" + atomicSequence.getNextAtomicIntegerArray());
}
if(test3Flag) {
//3-2.获取原子引用类型属性值线程2
System.out.println(Thread.currentThread().getName() + "原子引用类型属性值结果为---:" + atomicSequence.getNextAtomicIntegerFieldUpdater());
}
}
}
}).start();
new Thread(){
@Override
public void run() {
for(int i =0;i<20;i++) {
if(test1Flag) {
//1-3获取原子更新基本类型线程3
System.out.println(Thread.currentThread().getName() + "原子Integer结果为-:" + atomicSequence.getNextAtomicInteger());
}
if(test2Flag) {
//2-3.获取原子更新数组类型线程3
System.out.println(Thread.currentThread().getName() + "原子数组类型结果为---:" + atomicSequence.getNextAtomicIntegerArray());
}
if(test3Flag) {
//3-3.获取原子引用类型属性值线程3
System.out.println(Thread.currentThread().getName() + "原子引用类型属性值结果为---:" + atomicSequence.getNextAtomicIntegerFieldUpdater());
}
}
}
}.start();
}
}
public class User {
private String name;
//注意声明为volatile
public volatile int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
3.Atomic源码简介
大量用到了unsafe的api.和CAS.unsafe为不公开源码. 源码:
public class AtomicInteger extends Number implements java.io.Serializable {
public final int getAndUpdate(IntUnaryOperator updateFunction) {
int prev, next;
do {
//获取当前值
prev = get();
//获取next值
next = updateFunction.applyAsInt(prev);
//CAS,把当前值和期待的下一个值CAS,
//如果为true就返回prev,如果返回false,则继续重试.
} while (!compareAndSet(prev, next));
return prev;
}
public final boolean compareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
public final int get() {
return value;
}
}
4. LongAddr(JDK8开始)
4.1 Atomic原子类的缺点
由于Atomic用到了如下自旋,在高并发的情况下性能不好.
do {
prev = get();
next = updateFunction.applyAsInt(prev);
} while (!compareAndSet(prev, next));
4.2 LongAddr概述
LongAddr开始出现,同时还有DoubleAdder
4.4 源码
public class LongAdder extends Striped64 implements Serializable {
public void increment() {
add(1L);
}
public void decrement() {
add(-1L);
}
public void add(long x) {
//定义变量
Cell[] as; long b, v; int m; Cell a;
//as赋值等于cells,如果不为空(说明并发中的不是第一次);或者casBase(原子设置b=base,b+x)不成功
//㘝casBase设置完成则完成返回
if ((as = cells) != null || !casBase(b = base, b + x)) {
//初始化未争用标识
boolean uncontended = true;
if (as == null || (m = as.length - 1) < 0 ||
//获取当前线程的probe对应的cell，如果为空则初始化
(a = as[getProbe() & m]) == null ||
//uncontended这个是对线程对应的cell的值进行加一操作的结果，
//冲突说明了什么？hash到同一个cell的多个线程同时操作cas，得进入下一个方法处理
!(uncontended = a.cas(v = a.value, v + x)))
//longAccumulate是计算的核心方法
longAccumulate(x, null, uncontended);
}
}
public int intValue() {
return (int)sum();
}
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;
}
}
abstract class Striped64 extends Number {
final void longAccumulate(long x, LongBinaryOperator 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(x); // Optimistically create
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) ? v + x :
fn.applyAsLong(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(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; // Fall back on using base
}
}
}
4.5 LongAddr原理
LongAddr有多个值,可以竞争的资源多,抢到的概率大,如果抢占不到,还可能扩容.
有一个base值,然后多一个值cell,高并发时用多个cell累加
Java并发编程笔记之LongAdder和LongAccumulator源码探究
LongAdder源码分析(只分析了两个方法，add和longAccumulate，也是核心方法)
