多线程与高并发05-原子操做CAS
原子操做CAS-无锁优化乐观锁
什么是原子操做，如何实现原子操做
假定有两个操做A和B，若是从执行A的线程来看，当另外一个线程执行B时，要么将B所有执行完，要么彻底不执行B，那么A和B对彼此来讲是原子的java
实现原子操做可使用锁，锁机制，知足基本的需求是没有问题的了，可是有的时候咱们的需求并不是这么简单，咱们须要更有效，更加灵活的机制，synchronized关键字是基于阻塞的锁机制(锁升级)，也就是说当一个线程拥有锁的时候，访问同一资源的其它线程须要等待，直到该线程释放锁程序员
这里会有些问题：首先，若是被阻塞的线程优先级很高很重要怎么办？其次，若是得到锁的线程一直不释放锁怎么办？（这种状况是很是糟糕的）。还有一种状况，若是有大量的线程来竞争资源，那CPU将会花费大量的时间和资源来处理这些竞争，同时，还有可能出现一些例如死锁之类的状况，最后，其实锁机制是一种比较粗糙，粒度比较大的机制，相对于像计数器这样的需求有点儿过于笨重算法
实现原子操做还可使用当前的处理器基本都支持CAS()的指令，只不过每一个厂家所实现的算法并不同，每个CAS操做过程都包含三个运算符：数组
- 一个内存地址V
- 一个指望的值A
- 一个新值B
操做的时候若是这个地址上存放的值等于这个指望的值A，则将地址上的值赋为新值B，不然不作任何操做安全
CAS的基本思路就是，若是这个地址上的值和指望的值相等，则给其赋予新值，不然不作任何事儿，可是要返回原值是多少。循环CAS就是在一个循环里不断的作cas操做，直到成功为止
架构
CAS是怎么实现线程的安全呢:ide
语言层面不作处理，咱们将其交给硬件—CPU和内存，利用CPU的多处理能力，实现硬件层面的阻塞，再加上volatile变量的特性便可实现基于原子操做的线程安全
CAS实现原子操做的三大问题
ABA问题
由于CAS须要在操做值的时候，检查值有没有发生变化，若是没有发生变化则更新，可是若是一个值原来是A，变成了B，又变成了A，那么使用CAS进行检查时会发现它的值没有发生变化，可是实际上却变化了优化
ABA问题的解决思路就是使用版本号。在变量前面追加上版本号，每次变量更新的时候把版本号加1，那么A→B→A就会变成1A→2B→3A。举个通俗点的例子，你倒了一杯水放桌子上，干了点别的事，而后同事把你水喝了又给你从新倒了一杯水，你回来看水还在，拿起来就喝，若是你无论水中间被人喝过，只关心水还在，这就是ABA问题。this
若是你是一个讲卫生讲文明的小伙子，不但关心水在不在，还要在你离开的时候水被人动过没有，由于你是程序员，因此就想起了放了张纸在旁边，写上初始值0，别人喝水前麻烦先作个累加才能喝水atom
ABA问题只是一种现象，并不必定是问题，在架构设计中也有这种乐观锁的使用（幂等性操做）
循环时间长开销大
自旋CAS若是长时间不成功，会给CPU带来很是大的执行开销
只能保证一个共享变量的原子操做
当对一个共享变量执行操做时，咱们可使用循环CAS的方式来保证原子操做，可是对多个共享变量操做时，循环CAS就没法保证操做的原子性，这个时候就能够用锁
还有一个取巧的办法，就是把多个共享变量合并成一个共享变量来操做。好比，有两个共享变量i＝2，j=a，合并一下ij=2a，而后用CAS来操做ij。从Java 1.5开始，JDK提供了AtomicReference类来保证引用对象之间的原子性，就能够把多个变量放在一个对象里来进行CAS操做
JDK中相关原子操做类的使用
AtomicInteger
- int addAndGet（int delta）：以原子方式将输入的数值与实例中的值（AtomicInteger里的value）相加，并返回结果
- boolean compareAndSet（int expect，int update）：若是输入的数值等于预期值，则以原子方式将该值设置为输入的值
- int getAndIncrement()：以原子方式将当前值加1，注意，这里返回的是自增前的值
- int getAndSet（int newValue）：以原子方式设置为newValue的值，并返回旧值
示例代码：
/**
* 解决一样的问题的更高效的方法，使用AtomXXX类
* AtomXXX类自己方法都是原子性的，但不能保证多个方法连续调用是原子性的
*/
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
public class T01_AtomicInteger {
/*volatile*/ //int count1 = 0;
AtomicInteger count = new AtomicInteger(0);
/*synchronized*/ void m() {
for (int i = 0; i < 10000; i++)
//if count1.get() < 1000
count.incrementAndGet();
//count1++;
}
public static void main(String[] args) {
T01_AtomicInteger t = new T01_AtomicInteger();
List<Thread> threads = new ArrayList<Thread>();
for (int i = 0; i < 10; i++) {
threads.add(new Thread(t::m, "thread-" + i));
}
threads.forEach((o) -> o.start());
threads.forEach((o) -> {
try {
o.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
});
System.out.println(t.count);
}
}
运行结果：
100000
上面例子能够看出用AtomicInteger，和加synchronized锁效果是同样的，并且CAS效率更高
除了synchronized、AtomicInteger以外还有LongAdder，下面代码比较一下他们各自的效率：
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.LongAdder;
public class T02_AtomicVsSyncVsLongAdder {
static long count2 = 0L;
static AtomicLong count1 = new AtomicLong(0L);
static LongAdder count3 = new LongAdder();
public static void main(String[] args) throws Exception {
Thread[] threads = new Thread[1000];
for(int i=0; i<threads.length; i++) {
threads[i] =
new Thread(()-> {
for(int k=0; k<100000; k++) count1.incrementAndGet();
});
}
long start = System.currentTimeMillis();
for(Thread t : threads ) t.start();
for (Thread t : threads) t.join();
long end = System.currentTimeMillis();
//TimeUnit.SECONDS.sleep(10);
System.out.println("Atomic: " + count1.get() + " time " + (end-start));
//-----------------------------------------------------------
Object lock = new Object();
for(int i=0; i<threads.length; i++) {
threads[i] =
new Thread(new Runnable() {
@Override
public void run() {
for (int k = 0; k < 100000; k++)
synchronized (lock) {
count2++;
}
}
});
}
start = System.currentTimeMillis();
for(Thread t : threads ) t.start();
for (Thread t : threads) t.join();
end = System.currentTimeMillis();
System.out.println("Sync: " + count2 + " time " + (end-start));
//----------------------------------
for(int i=0; i<threads.length; i++) {
threads[i] =
new Thread(()-> {
for(int k=0; k<100000; k++) count3.increment();
});
}
start = System.currentTimeMillis();
for(Thread t : threads ) t.start();
for (Thread t : threads) t.join();
end = System.currentTimeMillis();
//TimeUnit.SECONDS.sleep(10);
System.out.println("LongAdder: " + count1.longValue() + " time " + (end-start));
}
static void microSleep(int m) {
try {
TimeUnit.MICROSECONDS.sleep(m);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
运行结果：
Atomic: 100000000 time 2255 Sync: 100000000 time 3257 LongAdder: 100000000 time 509
AtomicIntegerArray
主要是提供原子的方式更新数组里的整型，其经常使用方法以下：
- int addAndGet（int i，int delta）：以原子方式将输入值与数组中索引i的元素相加
- boolean compareAndSet（int i，int expect，int update）：若是当前值等于预期值，则以原子方式将数组位置i的元素设置成update值。
须要注意的是：
数组value经过构造方法传递进去，而后
AtomicIntegerArray会将
当前数组复制一份，因此当AtomicIntegerArray对内部的数组元素进行修改时，不会影响传入的数组
示例代码：
import java.util.concurrent.atomic.AtomicIntegerArray;
/**
*类说明：
*/
public class AtomicArray {
static int[] value = new int[] { 1, 2 };
static AtomicIntegerArray ai = new AtomicIntegerArray(value);
public static void main(String[] args) {
ai.getAndSet(0, 3);
System.out.println(ai.get(0));
System.out.println(value[0]);//原数组不会变化
}
}
运行结果：
3 1
更新引用类型
原子更新基本类型的AtomicInteger，只能更新一个变量，若是要原子更新多个变量，就须要使用这个原子更新引用类型提供的类。Atomic包提供了如下3个类
AtomicReference
原子更新引用类型
示例代码：
/**
*类说明：演示引用类型的原子操做类
*/
public class UseAtomicReference {
static AtomicReference<UserInfo> atomicUserRef;
public static void main(String[] args) {
//要修改的实体的实例
UserInfo user = new UserInfo("Mark", 15);
atomicUserRef = new AtomicReference(user);
UserInfo updateUser = new UserInfo("Bill",17);
atomicUserRef.compareAndSet(user,updateUser);
System.out.println(atomicUserRef.get());
System.out.println(user);
}
//定义一个实体类
static class UserInfo {
private volatile String name;
private int age;
public UserInfo(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
@Override
public String toString() {
return "UserInfo{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
}
运行结果：
UserInfo{name='Bill', age=17}
UserInfo{name='Mark', age=15}
锁的效率
LongAdder > Atomic > synchronized | | | 分段锁+CAS CAS 普通锁 线程多优点大 分段线程加CAS 最后把结果合起来
AtomicStampedReference
利用版本戳的形式记录了每次改变之后的版本号，这样的话就不会存在ABA问题了。这就是AtomicStampedReference的解决方案。AtomicMarkableReference跟AtomicStampedReference差很少， AtomicStampedReference是使用pair的int stamp做为计数器使用，AtomicMarkableReference的pair使用的是boolean mark。 仍是那个水的例子，AtomicStampedReference可能关心的是动过几回，AtomicMarkableReference关心的是有没有被人动过，方法都比较简单
示例代码：
import java.util.concurrent.atomic.AtomicStampedReference;
/**
*类说明：演示带版本戳的原子操做类
*/
public class UseAtomicStampedReference {
static AtomicStampedReference<String> asr
= new AtomicStampedReference("mark",0);
public static void main(String[] args) throws InterruptedException {
//拿到当前的版本号(旧)
final int oldStamp = asr.getStamp();
final String oldReference = asr.getReference();
System.out.println(oldReference+"============"+oldStamp);
Thread rightStampThread = new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+":当前变量值："
+oldReference + "-当前版本戳：" + oldStamp + "-"
+ asr.compareAndSet(oldReference,
oldReference + "+Java", oldStamp,
oldStamp + 1));
}
});
Thread errorStampThread = new Thread(new Runnable() {
@Override
public void run() {
String reference = asr.getReference();
System.out.println(Thread.currentThread().getName()
+":当前变量值："
+reference + "-当前版本戳：" + asr.getStamp() + "-"
+ asr.compareAndSet(reference,
reference + "+C", oldStamp,
oldStamp + 1));
}
});
rightStampThread.start();
rightStampThread.join();
errorStampThread.start();
errorStampThread.join();
System.out.println(asr.getReference()+"============"+asr.getStamp());
}
}
运行结果：
mark============0 Thread-0:当前变量值：mark-当前版本戳：0-true Thread-1:当前变量值：mark+Java-当前版本戳：1-false mark+Java============1
AtomicMarkableReference
原子更新带有标记位的引用类型。能够原子更新一个布尔类型的标记位和引用类型。构造方法是AtomicMarkableReference（V initialRef，booleaninitialMark）
原子更新字段类（不经常使用）
若是需原子地更新某个类里的某个字段时，就须要使用原子更新字段类，Atomic包提供了如下3个类进行原子字段更新
要想原子地更新字段类须要两步。第一步，由于原子更新字段类都是抽象类，每次使用的时候必须使用静态方法newUpdater()建立一个更新器，而且须要设置想要更新的类和属性。第二步，更新类的字段（属性）必须使用public volatile修饰符
AtomicIntegerFieldUpdater
原子更新整型的字段的更新器
AtomicLongFieldUpdater
原子更新长整型字段的更新器
AtomicReferenceFieldUpdater
原子更新引用类型里的字段
- 1. java多线程并发之原子操做/CAS以及原子类atomic
- 2. Java多线程与并发原理 --- CAS
- 3. C++多线程并发（五）---原子操做与无锁编程
- 4. JAVA并发编程（八）原子性与CAS操做、ABA问题
- 5. 并发编程-原子操作CAS
- 6. 线程并发-CAS及原子类
- 7. 原子操做(CAS)
- 8. CAS 原子操做
- 9. JUC多线程及高并发8-----CAS
- 10. 02.并发多线程-CAS
- 更多相关文章...
- • C# 多线程 - C#教程
- • Rust 并发编程 - RUST 教程
- • Java Agent入门实战（三）-JVM Attach原理与使用
- • Spring Cloud 微服务实战(三) - 服务注册与发现
-
每一个你不满意的现在，都有一个你没有努力的曾经。