文章目录
一、CAS操作
为什么需要CAS操作?
/**
给定一个需求:统计一个网站的访问量,规定每次访问都让count+1
*/
package PracticeCAS;
import java.util.concurrent.CountDownLatch;
public class demo {
static int count=0;
public static void request() throws InterruptedException {
Thread.sleep(5);
/**
* Q:每次获取到的count都不一样,这是为什么?如何解决
* A:
* 1.count++ 是有三步来完成的;(jvm执行引擎);
* 获取count值->讲count值+1->将这个值返回给count
* 2.多线程情况下, 如果有A/B两个线程,同时执行到 获取count值的这个步骤
* 那么就会导致,count值只加了1,这样就导致了结果不正确;
* 3.解决方式,在给count++的时候,做同步处理,同时只允许一个线程处理这个代码
* 这样的话,就不会丢数据了
* 4.在Java中 可以使用 synchronized或 ReentrantLock都可以是先对资源的加锁
* 保证资源的安全性和正确性
*/
count++;
}
public static void main(String[] args) throws InterruptedException {
long startTime=System.currentTimeMillis();
int size=100;
CountDownLatch countDownLatch=new CountDownLatch(size);
for (int i = 0; i < size; i++) {
new Thread(new Runnable() {
@Override
public void run() {
try{
for (int j = 0; j < 10; j++) {
request();
}
}catch (Exception e){
e.printStackTrace();
}finally {
countDownLatch.countDown();
}
}
}).start();
}
countDownLatch.await();
long endTime=System.currentTimeMillis();
System.out.println(endTime-startTime);
System.out.println(count);
}
}
常规解决数据不正确方式:
package PracticeCAS;
import java.util.concurrent.CountDownLatch;
public class demo02 {
static int count=0;
public synchronized static void request() throws InterruptedException {
Thread.sleep(5);
/**
* Q:耗时太长的原因?
* A:
* 1.程序中的 synchronized 保证了这个方法同一时刻只有一个线程进入;
* 这样虽然让count的值一定正确,但却延长了执行的时间
* 那么如果解决的运行时间长的问题呢?
* 解决方法就是把锁加到第三步,也就是 把加好的值返回给count的这一步加锁
*
* 原来版本的三步:
* 1.获取count值
* 2.讲count值+1
* 3.将这个值返回给count
*
* 现在把第三步修改为:
* 1.获取锁
* 2.获取现在最新的值
* 3.判断最新的值,是否等于原来的值;如果相等,把结果返回给count
* 4.释放锁
*/
count++;
}
public static void main(String[] args) throws InterruptedException {
long startTime=System.currentTimeMillis();
int size=100;
CountDownLatch countDownLatch=new CountDownLatch(size);
for (int i = 0; i < size; i++) {
new Thread(new Runnable() {
@Override
public void run() {
try{
for (int j = 0; j < 10; j++) {
request();
}
}catch (Exception e){
e.printStackTrace();
}finally {
countDownLatch.countDown();
}
}
}).start();
}
countDownLatch.await();
long endTime=System.currentTimeMillis();
System.out.println(endTime-startTime);
System.out.println(count);
}
}
模拟CAS操作实现:
package PracticeCAS;
import java.util.concurrent.CountDownLatch;
/**
* 模拟CAS执行原理
*/
public class demo03 {
volatile static int count = 0;
public static void request() throws InterruptedException {
Thread.sleep(5);
// count++;
int expectCount;
while (!compareAndSwap(expectCount = getCount(), expectCount + 1)) ;
}
/**
* @param expectCount 老值,或者也叫原来获取到的count值
* @param newCount 新值,也就是需要赋值回去的值
* @return
*/
public static synchronized boolean compareAndSwap(int expectCount, int newCount) {
if (getCount() == expectCount) {
count = newCount;
return true;
} else {
return false;
}
}
public static int getCount() {
return count;
}
public static void main(String[] args) throws InterruptedException {
long startTime = System.currentTimeMillis();
int size = 1000;
CountDownLatch countDownLatch = new CountDownLatch(size);
for (int i = 0; i < size; i++) {
new Thread(new Runnable() {
@Override
public void run() {
try {
for (int j = 0; j < 10; j++) {
request();
}
} catch (Exception e) {
e.printStackTrace();
} finally {
countDownLatch.countDown();
}
}
}).start();
}
countDownLatch.await();
long endTime = System.currentTimeMillis();
System.out.println(endTime - startTime);
System.out.println(count);
}
}
二、Java中的CAS操作
CAS 全程ComparaAndSwap,中文翻译为:比较并替换
定义:
CAS操作包含三个操作数——内存位置(V)、期望值(A)和新值(B)
如果内存位置的值与期望值匹配,那么处理器就会自动将该位置值更新为新值,否则,处理器不做任何操作;无论那种情况,它都会在CAS指令之前返回该位置的值;
CAS在一些特殊情况下仅返回CAS是否成功,而不提取当前值,CAS有效的说明了
我人为位置V应该包含值A;如果包含该值,则将B放到这个位置;否则,不要改变该位置的值;只要告诉我这个位置现在的值即可;
Q:怎么使用JDK提供的CAS支持?
A:Java中提供了CAS操作的支持,具体在sun.misc.unsafe类中;具体声明如下:
public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5);
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);
/**
var1:表示要操作的对象
var2:表示要操作对象中属性地址的偏移量
var4:表示需要需要修改数据期望的值
var5:表示需要修改为的新值
*/
Q:CAS实现原理是什么?
A:
CAS通过JNI的代码来实现;JNI:Java native Interface,运行Java调用其他语言,而CompareAndSwapxxx系列的方法就是借助C语言来调用CPU底层指令实现的
以常用的intel x86平台来说,最终映射到CPU的指令为cmpxchg,这是一个原子指令
CPU执行此命令时,实现比较替换操作;
Q:现在的计算动不动上百核心,那么cmpxchg如何保证多核心下的线程安全?
A:系统底层进行CAS操作的时候,会判断当前系统是否为多核心系统;如果是多核心,就给从总线加锁,加所之后只有一个线程对总线加所成功,加锁成功之后,才会执行CAS操作,也就是说CAS的原子性时平台级别的!
Q:CAS这么牛逼,那么它还存在那些问题?
A:1.高并发场景下,对于一个操作有多个线程来执行CAS操作的时候,其他没有进入CAS操作的线程,依然会执行操作,当执行到最后一步的时候,直接开始了下一轮的计算;一直等到成功为止;
**2.ABA问题?**
Q:什么是ABA问题?
A:CAS需要在操作值的时候检查下值,有没有发生变化,如果没有发生变化则更新,但是如果一个值原来是A,在CAS方法执行之前,被其他线程修改为B,然后又修改回了A,那么CAS方法执行检查的时候就会发现他的值没有修改,但是实际缺变化了,这就是CAS的ABA问题;
ABA问题详解: 其实可以理解为一个线程在执行CAS操作之前,他的CPU被别人抢走了,这个时候,其他线程修改A的值,把A修改为B,又把B修改为A,这个时候原来的线程才拿到CPU,这个时候进入CAS操作之后,这个线程发现需要操作的值没有修改,但实际上,A的值已经被修改两次了;
//代码演示 ABA问题
package PracticeCAS;
import java.util.concurrent.atomic.AtomicInteger;
public class CasABADemo {
//原子变量 AtomicInteger
public static AtomicInteger a = new AtomicInteger(1);
public static void main(String[] args) {
Thread main = new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " " + a.get());
int expectInt = a.get();
int newInt = expectInt + 1;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
boolean compareAndSet = a.compareAndSet(expectInt, newInt);
System.out.println(compareAndSet);
System.out.println(a.get());
}
});
Thread ganrao = new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
a.incrementAndGet();
System.out.println(a.get());
a.decrementAndGet();
System.out.println(a.get());
}
});
main.start();
ganrao.start();
}
}
Q:jdk如何解决ABA问题?
A:使用AtomicStampedReference;AtomicStampedReference主要包含一个对象引用以及一个可以自动更新的正数 stamp的Pair对象来解决ABA问题;
提示:使用AtomicStampedReference修改ABA BUG;
JDK解决思路:
通过添加版本来记录对应值的变化,只要版本号匹配不上,哪怕值是相同的也无法可以识别出来
模拟JDK解决ABA问题:
package PracticeCAS;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicStampedReference;
public class DealABADemo {
//原子变量 AtomicInteger
public static AtomicStampedReference<Integer> a = new AtomicStampedReference<>(new Integer(1), 1);
public static void main(String[] args) {
Thread main = new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " " + a.getStamp());
Integer expectR = a.getReference();
Integer expectStamp = a.getStamp();
Integer newP = expectR + 1;
Integer newStamp = expectStamp + 1;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
boolean compareAndSet = a.compareAndSet(expectR, newP,expectStamp, newStamp);
System.out.println(compareAndSet);
System.out.println(a.getReference());
System.out.println(a.getStamp());
}
});
Thread ganrao = new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
a.compareAndSet(a.getReference(), a.getReference() + 1, a.getStamp(), a.getStamp() + 1);
System.out.println(a.getReference());
System.out.println(a.getStamp());
a.compareAndSet(a.getReference(), a.getReference() - 1, a.getStamp(), a.getStamp() + 1);
System.out.println(a.getReference());
System.out.println(a.getStamp());
}
});
main.start();
ganrao.start();
}
}