概念
原子性
原子性是指一个操作是不可中断的，即使是在多个线程一起执行的时候，一旦操作开始，就不会被其他线程干扰。
有序性
线程并发时，程序的执行可能就会出现乱序。
可见性
可见性是值当一个线程修改了某一个共享变量的值，其他线程是否能够立即知道这个修改。
无锁
无锁类的原理
CAS（compare and swap）
CAS有3个操作数，内存值V，旧的预期值A，要修改的新值B。当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做。CAS是项乐观锁技术，当多个线程尝试使用CAS同时更新同一个变量时，只有其中一个线程能更新变量的值，而其它线程都失败，失败的线程并不会被挂起，而是被告知这次竞争中失败，并可以再次尝试。CAS是一个原子操作。
无锁类的使用
AtomicInteger
无锁的整型数，主要方法如下：
- int get()：取得当前值
- void set(int newValue)：设置新值
- int getAndSet(int newValue)：返回旧值，设置新值
- boolean compareAndSet(int expect, int u)：如果当前值为expect，则设置新值
- int getAndIncrement()：返回旧值，当前值+1
- int getAndDecrement()：返回旧值，当前值-1
- int getAndAdd(int delta)：返回旧值，当前值+dleta
- int incrementAndGet()：当前值+1，返回新值
- int decrementAndGet()：当前值-1，返回新值
- int addAbdGet(int delta)：当前值+delta，返回新值
Unsafe
非安全的操作。
（1）Info相关。主要返回某些低级别的内存信息：addressSize(), pageSize()
（2）Objects相关。主要提供Object和它的域操纵方法：allocateInstance(),objectFieldOffset()
（3）Class相关。主要提供Class和它的静态域操纵方法：staticFieldOffset(),defineClass(),defineAnonymousClass(),ensureClassInitialized()
（4）Arrays相关。数组操纵方法：arrayBaseOffset(),arrayIndexScale()
（5）Synchronization相关。主要提供低级别同步原语（如基于CPU的CAS（Compare-And-Swap）原语）：monitorEnter(),tryMonitorEnter(),monitorExit(),compareAndSwapInt(),putOrderedInt()
（6）Memory相关。直接内存访问方法（绕过JVM堆直接操纵本地内存）：allocateMemory(),copyMemory(),freeMemory(),getAddress(),getInt(),putInt()
示例代码如下：
public class TestAtomicInteger {
private static AtomicInteger i = new AtomicInteger(0);
public static void main(String[] args) throws InterruptedException {
Thread[] ts = new Thread[5];
for (int l = 0; l < 5; l++) {
ts[l] = new Thread(new AtomicIntegerThread());
}
for (int l = 0; l < 5; l++) ts[l].start();
for (int l = 0; l < 5; l++) ts[l].join();
System.out.println(i.get());
}
static class AtomicIntegerThread extends Thread {
@Override
public void run() {
for (int k = 0; k < 10000; k++) {
i.incrementAndGet();
}
}
}
}
测试打印结果为50000，是正确结果，相比使用Synchronizez同步块速度快的多。
AtomicReference
对引用进行修改，是一个模板类，抽象化了数据类型，示例代码如下：
public class TestAtomicReference {
private static AtomicReference<String> i = new AtomicReference<>("abc");
public static void main(String[] args) throws InterruptedException {
Thread[] ts = new Thread[5];
for (int l = 0; l < 5; l++) {
ts[l] = new Thread(new AtomicReferenceThread());
}
for (int l = 0; l < 5; l++) ts[l].start();
for (int l = 0; l < 5; l++) ts[l].join();
}
static class AtomicReferenceThread extends Thread {
@Override
public void run() {
if (i.compareAndSet("abc", "123")) {
System.out.println(Thread.currentThread().getId() + "修改成功");
} else {
System.out.println(Thread.currentThread().getId() + "修改失败");
}
}
}
}
AtomicStampedReference<T>
加上时间戳的一个无锁模板类，利用时间戳防止出现多次重复修改等情况，如下模拟充值（每人一次，防止出现充值，消费，再充值）。
public class TestAtomicStampedReference {
static AtomicStampedReference<Integer> money = new AtomicStampedReference<>(19, 0);
public static void main(String[] args) {
// 模拟多个线程同时更新后台数据库,为用户充值
for (int i = 0; i < 3; i++) {
final int timeStamp = money.getStamp();
new Thread(new Runnable() {
@Override
public void run() {
while (true) {
while (true) {
Integer m = money.getReference();
if (m < 20) {
if (money.compareAndSet(m, m + 20, timeStamp, timeStamp + 1)) {
System.out.println("余额小于20元,充值成功,当前余额为:" + money.getReference());
break;
}
} else {
// System.out.println("余额大于20元");
break;
}
}
}
}
}).start();
}
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
while (true) {
int timeStamp = money.getStamp();
Integer m = money.getReference();
if (m > 10) {
if (money.compareAndSet(m, m - 10, timeStamp, timeStamp + 1)) {
System.out.println("消费10元,当前余额:" + money.getReference());
}
} else {
System.out.println("没有足够金额消费");
break;
}
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}).start();
}
}
AtomicIntegerArray
无锁的整型数组，API：
- int get(int i)：获取下标为i的值
- int length()：数组的长度
- int getAndSet(int i,int newValue)：获取旧值，这是新值
- boolean compareAndSet(int i, int expect, int update)：进行CAS操作，若果下标i的值为expect，则设置为update
- int getAndIncrement(int i)：获取旧值，并+1
- int getAndDecrement(int i)：获取旧值，并-1
- int getAndAdd(int i,int delta)：获取旧值，并+delta（可以为负）
示例代码如下：
public class TestAtomicArray {
static AtomicIntegerArray arr = new AtomicIntegerArray(10);
public static void main(String[] args) throws InterruptedException {
Thread[] ts = new Thread[10];
for (int k = 0; k < 10; k++) {
ts[k] = new Thread(new TestAtomicArrayThread());
}
for (int k = 0; k < 10; k++) ts[k].start();
for (int k = 0; k < 10; k++) ts[k].join();
System.out.println(arr);
}
static class TestAtomicArrayThread implements Runnable {
@Override
public void run() {
for (int k = 0; k < 10000; k++) {
arr.getAndIncrement(k % arr.length());
}
}
}
}
private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final int base = unsafe.arrayBaseOffset(int[].class);
private static final int shift;
private final int[] array;
static {
int scale = unsafe.arrayIndexScale(int[].class);
if ((scale & (scale - 1)) != 0)
throw new Error("data type scale not a power of two");
shift = 31 - Integer.numberOfLeadingZeros(scale);
}
注：base，为数组在C层的基（头）地址；scale为数据类型的长度，int型长度就为4；shift就是偏移量，用于定位下标为i的数据地址。
AtomicIntegerFieldUpdater<T>
让原本没有定义为Atomic类型的数据，也可以使用原子操作。示例代码如下：
public class TestAtomicIntegerFieldUpdater {
public static class Candidate {
int id;
volatile int score;
}
public final static AtomicIntegerFieldUpdater<Candidate> scoreUpdater = AtomicIntegerFieldUpdater.newUpdater(Candidate.class, "score");
public static AtomicInteger allScore = new AtomicInteger(0);
public static void main(String[] args) throws InterruptedException {
final Candidate stu = new Candidate();
Thread[] t = new Thread[100000];
for (int i = 0; i < 100000; i++) {
t[i] = new Thread(new Runnable() {
@Override
public void run() {
scoreUpdater.incrementAndGet(stu);
allScore.incrementAndGet();
}
});
t[i].start();
}
for (int i = 0; i < 50000; i++) t[i].join();
System.out.println("score:" + stu.score);
System.out.println("allScore:" + allScore);
}
}
stu实例的score对象本身不是线程安全的，现在使用Updater进行更新，让字段变的线程安全。与AtomicInteger进行对比，数据一致，说明没有错误。
应用：Amino框架
该组件将提供一套免锁的集合类（LockFreeVector、LockFreeList、LockFreeSet等）、树结构、图结构。因为这些数据结构采用免锁的运算法则来生成，所以，它们将拥有基本的免锁组件的特性，如可以避免不同类型的死锁，不同类型的线程初始化顺序等。
Amino 还提供了一些非常有用的并行计算模式，包括 Master-Worker、Map-reduce、Divide and conquer, Pipeline 等。
Amino并没有加入到官方jdk中，因此需要自行下载、导入。
下载地址：http://sourceforge.net/projects/amino-cbbs/files/
小结
Atomic对Java的Integer、Boolean、Long都有封装，或者使用Reference引用类型，无锁的实现比同步代码运行效率高得多，具体可查看JAVA源码。
扫一扫
3861
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
