当前位置：首页 > news >正文

网站建设的费用结构/百度app安装下载

news 2025/6/30 12:57:01

网站建设的费用结构,百度app安装下载,大连网站制作哪家最好,w3c验证网站并发之atomic与CAS自旋锁通过前几章的讲解我们知道i这种类似操作是不安全的。针对这种情况，我们可能会想到利用synchronize关键字实现线程同步，保证操作的原子性，的确这是一种有效的方法，但我们还有一种选择--AtomicInteger。 At…

并发之atomic与CAS自旋锁

通过前几章的讲解我们知道i++这种类似操作是不安全的。针对这种情况，我们可能会想到利用synchronize关键字实现线程同步，保证++操作的原子性，的确这是一种有效的方法，但我们还有一种选择--AtomicInteger。

AtomicInteger解析

源码

成员解析

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;

Unsafe 类是用来在任意内存地址位置处读写数据，可见，对于普通用户来说，使用起来还是比较危险的。
valueOffset 表示该变量在内存中的地址。
value;当前类中存储的值

方法

两个构造方法，赋初始值,不传参数则默认为0

public AtomicInteger(int initialValue) {value = initialValue;
}
public AtomicInteger() {
}

取值和设置值

这个值是volatile的所以是能保证可见性的

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);
}

既然用volatile修饰了那么常规赋值方式到底有什么用呢？
首先volatile关键字这一章中将到

volatile变量的读操作，会强制使CPU缓存失效，强制从内存读取变量。
写volatile变量，会强制刷新CPU写缓冲区，把缓存数据写到主内存。
而这些都是通过内存屏障实现的。如果该AtomicInteger在锁中，而锁住的代码块并不会产生可见性问题，那么volatile的操作会让系统添加多个屏障。而使用lazySet()就是在不需要让共享变量的修改立刻让其他线程可见的时候，以设置普通变量的方式来修改共享状态，可以减少不必要的内存屏障，从而提高程序执行的效率。

该方法将新值设置进去的同时将旧值返回回来

public final int getAndSet(int newValue) {return unsafe.getAndSetInt(this, valueOffset, newValue);
}

比较期望值并且更新该值原子操作

public final boolean compareAndSet(int expect, int update) {return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
//示例
@Test
public void compareAndSetTest(){AtomicInteger a = new AtomicInteger(10);a.compareAndSet(10,15);log.info("{}",a.get());a.weakCompareAndSet(10,12);log.info("{}",a.get());
}

结果：
13:42:36.391 [main] INFO atomic.AtomicIntegerApiExample - 15
13:42:36.404 [main] INFO atomic.AtomicIntegerApiExample - 15
可以看到第二个语句没有替换成功

比较并且更新，和lazySet一样用于锁中

public final boolean weakCompareAndSet(int expect, int update) {return unsafe.compareAndSwapInt(this, valueOffset, expect, update);}

原子减操作

//先获取后再加1
public final int getAndIncrement() {return unsafe.getAndAddInt(this, valueOffset, 1);
}
public final int getAndAdd(int delta) {return unsafe.getAndAddInt(this, valueOffset, delta);
}
//先加后获取
public final int incrementAndGet() {return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}
public final int addAndGet(int delta) {return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
}//减1操作
public final int getAndDecrement() {return unsafe.getAndAddInt(this, valueOffset, -1);
}
//先减1然后获取
public final int decrementAndGet() {return unsafe.getAndAddInt(this, valueOffset, -1) - 1;
}

对数据执行方法更新。

传入一个lambda算法，然后按照该算法更新数据。将当前数据更新为

public final int updateAndGet(IntUnaryOperator updateFunction) {int prev, next;do {//取值prev = get();//做操作next = updateFunction.applyAsInt(prev);//原子替换} while (!compareAndSet(prev, next));return next;
}
//演示
//读取atomicInteger里面的值做lambda表达式的操作。
//
public void updateAndGetTest(){AtomicInteger atomicInteger = new AtomicInteger(10);IntUnaryOperator updateFunction = (a)->a*5+3;atomicInteger.updateAndGet(updateFunction);assert Objects.equals(atomicInteger.get(),53);
}

两个参数负责运算。

public final int getAndAccumulate(int x,IntBinaryOperator accumulatorFunction) {int prev, next;do {prev = get();next = accumulatorFunction.applyAsInt(prev, x);} while (!compareAndSet(prev, next));return prev;}public final int accumulateAndGet(int x,IntBinaryOperator accumulatorFunction) {int prev, next;do {prev = get();next = accumulatorFunction.applyAsInt(prev, x);} while (!compareAndSet(prev, next));return next;}//示例@Test
public void getAndAccumulateTest(){AtomicInteger atomicInteger = new AtomicInteger(10);IntBinaryOperator intBinaryOperator = (a,b)->(b-a)*2;atomicInteger.accumulateAndGet(2,intBinaryOperator);System.out.println(atomicInteger.get());
}

字符串方法取值方法

public String toString() {return Integer.toString(get());
}
public int intValue() {return get();
}
public long longValue() {return (long)get();
}
public float floatValue() {return (float)get();
}
public double doubleValue() {return (double)get();
}

CAS机制

定义

比如自增1算法中

public final int getAndIncrement() {return unsafe.getAndAddInt(this, valueOffset, 1);
}

AndAddInt的底层逻辑是什么

public final int getAndAddInt(Object var1, long var2, int var4) {int var5;do {var5 = this.getIntVolatile(var1, var2);} while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));return var5;
}

我们看到了一个方法的调用compareAndSwap,取这三个单词的首字母即为CAS。

他具体是怎么操作的呢。
var1 AtomicInteger对象本身。
var2 该对象值得引用地址。
var4 需要变动的数量。
var5 是用过var1 var2 找出的主内存中真实的值。

用该对象当前的值与var5比较，如果相同更新var5+var4并且返回true,如果不相同继续取值然后在比较，直到更新完成。
简单的来说：

CAS （CompareAndSwap） 比较当前工作内存中的值和主内存中的值，如果相同则执行规定操作，否则继续比较直到主内存和工作内存中的值一致为止.

这个CAS方法是原子性的在加上该变量由于使用了volatile修饰所以也可以保证可见性和有序性，可以模拟一个锁。通过这种比较的方式可以有效的减少锁带来的性能降低的问题。

问题

这么做并不是十全十美的，这里有2个比较大的问题。

并发竞争

在并发竞争比较严重的场合会严重的增加cpu的运算量。

在并发竞争不严重的场合中CAS的并发处理速度是远远高于锁的,但是在竞争比较严重的场合中，因为每个线程都在执行循环判断，所以会消耗大量cpu的运算能力。在这种情况下synchronized反而是一个更好的选择。

ABA

可能出现了一个线程修改了该数据另外一个线程又修改了回来，第三个线程并没有发现该变量变化过了。即ABA问题。
我们先来看一个例子：

private static AtomicInteger atomicInt = new AtomicInteger(100);public static void main(String[] args) throws InterruptedException {ExecutorService executorService = Executors.newCachedThreadPool();executorService.execute(()->{//进行一次ABA操作atomicInt.compareAndSet(100, 101);atomicInt.compareAndSet(101, 100);});executorService.execute(()->{try {//等待ABA执行完毕TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}//判断ABA向他婆娘个则替换 返回替换结果boolean c3 = atomicInt.compareAndSet(100, 101);//trueSystem.out.println(c3);});executorService.shutdown();
}

从上述例子中可以看出atomicInt并没有意识到自己的100与原始的100有什么差别，并且被替换成功。

举个现实中的栗子：你非常渴的情况下你发现一个盛满水的杯子，你一饮而尽。之后再给杯子里重新倒满水然后下无色无味的毒。然后你离开，当杯子的真正主人回来时看到杯子还是盛满水，他当然不知道是否被人喝完重新倒满。他只知道杯子和水还是原来的样子。这是他喝下了水，中毒了。

这里就引申出了一个问题：ABA到底会发生在什么样的数据结构中。会产生错误呢呢？

@Test
public void testABA(){AtomicInteger a = new AtomicInteger(10);int x = a.hashCode();log.info("a= {}  code={}",a.get(),x);AtomicInteger b = a;a.set(20);int y = a.hashCode();log.info("a= {}  code={}",a.get(),y);log.info("res={}",b.equals(a));
}

11:53:24.257 [main] INFO atomic.AtomicIntegerApiExample - a= 10 code=2007331442
11:53:24.267 [main] INFO atomic.AtomicIntegerApiExample - a= 20 code=2007331442
11:53:24.267 [main] INFO atomic.AtomicIntegerApiExample - res=true

通过上述的例子可以看到a引用并没有变化，但是引用的对象其中的值发生了变化那么实际上他a的应用还是a的引用然而引用的对象却不是原始对象了。这就好比被"调包“了。

当然ABA 问题，表面上上不会影响你的业务逻辑，但是在有些情况下，发生这种中途 “调包” 的事情，还是会有影响。

如何避免ABA问题：
通常的做法是在CAS的每一次操作上添加一个版本号。每次不仅比较引用而且需要对比版本号。当两者都相同时才能确认A就是A,而不是ABA。
幸好JDK中提供了AtomicStampedReference用于解决ABA的问题。

//值以及初级版本号
private static AtomicStampedReference<Integer> atomicStampedRef = new AtomicStampedReference<Integer>(100, 0);
public static void main(String[] args) throws InterruptedException {ExecutorService executorService = Executors.newCachedThreadPool();executorService.execute(()->{atomicStampedRef.compareAndSet(100, 101,atomicStampedRef.getStamp(), atomicStampedRef.getStamp()+1);atomicStampedRef.compareAndSet(101, 100,atomicStampedRef.getStamp(), atomicStampedRef.getStamp()+1);});executorService.execute(()->{int stamp = atomicStampedRef.getStamp();// stamp = 0System.out.println("before sleep : stamp = " + stamp);try {TimeUnit.SECONDS.sleep(2);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("after sleep : stamp = " + atomicStampedRef.getStamp());//stamp = 1boolean c3 = atomicStampedRef.compareAndSet(100, 101, stamp, stamp+1);System.out.println(c3);        //false});executorService.shutdown();
}

结果
before sleep : stamp = 0
after sleep : stamp = 2
false

我们可以看到版本号由0变成了2
结果也是不相同。可以说缓解了ABA的问题。