0%

原子操作

原子操作

在java.util.concurrent.atomic包下提供了很多原子操作类,多个线程执行一个操作时,其中任何一个线程要么完全执行此操作,要么没有执行此操作的任何步骤,其内部使用的CAS操作 乐观锁

以AtomicInteger为例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
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();
private static final long valueOffset;

static {
try {
valueOffset = unsafe.objectFieldOffset
(AtomicInteger.class.getDeclaredField("value"));
} catch (Exception ex) { throw new Error(ex); }
}

private volatile int value;

// 获取当前值
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);
}

// 以原子方式设置给定值,并返回旧值 线程安全版本的 tmp = oldValue; oldValue = newValue; return oldValue
public final int getAndSet(int newValue) {
return unsafe.getAndSetInt(this, valueOffset, newValue);
}

// 如果当前值等于预期值,则以原子方式设置为给定的更新值,成功则返回true,失败返回false
public final boolean compareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}

// 如果当前值等于预期值,则以原子方式设置为给定的更新值,成功则返回true,失败返回false
// 与compareAndSet方法一样
public final boolean weakCompareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}

// 以原子方式加一 ,相当于线程安全版的i++
public final int getAndIncrement() {
return unsafe.getAndAddInt(this, valueOffset, 1);
}

// 以原子方式减一 ,相当于线程安全版的i--
public final int getAndDecrement() {
return unsafe.getAndAddInt(this, valueOffset, -1);
}

// 以原子方式将给定值与当前值相加 线程安全版的i=+10 先获取再相加
public final int getAndAdd(int delta) {
return unsafe.getAndAddInt(this, valueOffset, delta);
}

// 以原子方式加一 ,相当于线程安全版的++i
public final int incrementAndGet() {
return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}

// 以原子方式减一 ,相当于线程安全版的--i
public final int decrementAndGet() {
return unsafe.getAndAddInt(this, valueOffset, -1) - 1;
}

// 以原子方式将给定值与当前值相加 线程安全版的i+=10 先相加在获取
public final int addAndGet(int delta) {
return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
}

}

指令重排序

JVM会根据处理器的特性适当的重新排序机器指令,使机器指令更符合CPU的执行特点,最大限度的发挥机器的性能,但是会导致执行顺序可能会与代码顺序不一致