public final boolean compareAndSet(int expect, int update) //如果输入的值和期望值相等就set并返回true/false
public final int getAndIncrement() //对AtomicInteger原子的加1并返回当前自增前的value
public final int getAndDecrement() //对AtomicInteger原子的减1并返回自减之前的的value
public final int getAndAdd(int delta) //对AtomicInteger原子的加上delta值并返加之前的value
public final int incrementAndGet() //对AtomicInteger原子的加1并返回加1后的值
public final int decrementAndGet() //对AtomicInteger原子的减1并返回减1后的值
public final int addAndGet(int delta) //给AtomicInteger原子的加上指定的delta值并返回加后的值
示例:
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicInteger;
@Slf4j
public class AtomicIntegerExample {
// 请求总数
public static int clientTotal = 5000;
// 同时并发执行的线程数
public static int threadTotal = 200;
public static AtomicInteger count = new AtomicInteger(0);
public static void main(String[] args) throws Exception {
//获取线程池
ExecutorService executorService = Executors.newCachedThreadPool();
//定义信号量
final Semaphore semaphore = new Semaphore(threadTotal);
final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
for (int i = 0; i < clientTotal ; i++) {
executorService.execute(() -> {
try {
semaphore.acquire();
add();
semaphore.release();
} catch (Exception e) {
log.error(“exception”, e);
}
countDownLatch.countDown();
});
}
countDownLatch.await();
executorService.shutdown();
log.info(“count:{}”, count.get());
}
private static void add() {
count.incrementAndGet();
}
}
这里我们使用请求总数为:5000
,同时执行的并发线程数为:200
,我们最终需要得到结果为:5000
,这个执行结果才算正确。
查看返回结果:
13:43:26.473 [main] INFO com.mmall.concurrency.example.atomic.AtomicIntegerExample - count:5000
最后结果是 5000
表示是线程安全的。
我们来看看 AtomicInteger
底层代码中到底为我们做了什么?首先我们来看 AtomicInteger.incrementAndGet()
方法
public class AtomicInteger extends Number implements java.io.Serializable{
/**
-
对AtomicInteger原子的加1并返回加1后的值
-
@return 更新的值
*/
public final int incrementAndGet() {
return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}
}
AtomicInteger
调用了java底层的 unsafe.getAndAddInt()
方法,这里是实现CAS 的关键。
incrementAndGet()
是将自增后的值返回,还有一个方法getAndIncrement()
是将自增前的值返回,分别对应++i
和i++
操作。同样的decrementAndGet()
和getAndDecrement()
则对--i
和i--
操作。
Unsafe类是在sun.misc包下,不属于Java标准。但是很多Java的基础类库,包括一些被广泛使用的高性能开发库都是基于
Unsafe类开发的,比如Netty、Cassandra、Hadoop、Kafka等。Unsafe类在提升Java运行效率,增强Java语言底层操作
能力方面起了很大的作用。Unsafe类使Java拥有了像C语言的指针一样操作内存空间的能力,同时也带来了指针的问题。
过度的使用Unsafe类会使得出错的几率变大,因此Java官方并不建议使用的,官方文档也几乎没有。通常我们最好也不
要使用Unsafe类,除非有明确的目的,并且也要对它有深入的了解才行。
再来看 Unsafe.getAndAddInt()
方法
/*
-
其中getIntVolatile和compareAndSwapInt都是native方法
-
getIntVolatile是获取当前的期望值
-
compareAndSwapInt就是我们平时说的CAS(compare and swap),通过比较如果内存区的值没有改变,那么就用新值直接给该内存区赋值
*/
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;
}
public native int getIntVolatile(Object var1, long var2);
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
我们可以看到getAndAddInt(Object var1, long var2, int var4)
,传进来的第一个参数是当前的一个对象,也就是我们的:count.incrementAndGet()
,在getAndAddInt()
中,var1就是count,var2就是当前的值,比如当前循环中count值为 2,var4为每次递增1
其次getAndAddInt()
方法中涉及到的两个方法调用都定义为native,即java底层实现的本地方法
-
getIntVolatile():获取保存当前对象count的主存地址的引用(注意不是对象的值,是引用)。
-
compareAndSwapInt():比较当前对象的值和底层该对象的值是否相等,如果相等,则将当前对象值加1,如果不相等,则重新去获取底层该对象的值,这个方法的实现就是CPU的CAS(compare and swap)操作。
我们知道volatile
具有一致性的特征,但是它不具备原子性,为什么AtomicInteger
却同时具备一致性和原子性,原来在AtomicInteger
源码中实现了这样一串代码:private volatile int value;
,在AtomicInteger
内部实现就使用了volatile
关键字,这就是为什么执行CAS(对CAS有疑问的点击此处)操作的时候,从底层获取的数据就是最新的数据:
如果当前要保存的值和内存中最新的值不相等的话,说明在这个过程中被其他线程修改了,只
能获取更新当前值为最新值,再那这个当前值再去和重新去内存获取的最新值比较,直到二者
相等的时候,才完成+1的过程.
使用AtomicInteger
的好处在于,它不同于sychronized
关键字或lock
用锁的形式来实现原子性,加锁会影响性能,而是采用循环比较的形式来提高性能。
3.1.2、AtomicLong
AtomicLong
是作用是对长整形进行原子操作,依靠底层的cas来保障原子性的更新数据,在要添加或者减少的时候,会使用死循环不断地cas到特定的值,从而达到更新数据的目的。
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicLong;
@Slf4j
public class AtomicLongExample {
// 请求总数
public static int clientTotal = 5000;
// 同时并发执行的线程数
public static int threadTotal = 200;
public static AtomicLong count = new AtomicLong(0);
public static void main(String[] args) throws Exception {
ExecutorService executorService = Executors.newCachedThreadPool();
final Semaphore semaphore = new Semaphore(threadTotal);
final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
for (int i = 0; i < clientTotal ; i++) {
executorService.execute(() -> {
try {
semaphore.acquire();
add();
semaphore.release();
} catch (Exception e) {
log.error(“exception”, e);
}
countDownLatch.countDown();
});
}
countDownLatch.await();
executorService.shutdown();
log.info(“count:{}”, count.get());
}
private static void add() {
count.incrementAndGet();
// count.getAndIncrement();
}
}
执行结果:
14:59:38.978 [main] INFO com.mmall.concurrency.example.atomic.AtomicLongExample - count:5000
最后结果是 5000
表示是线程安全的。
3.1.3、AtomicBoolean
AtomicBoolean位于java.util.concurrent.atomic包下,是java提供给的可以保证数据的原子性操作的一个类
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicBoolean;
@Slf4j
public class AtomicBooleanExample {
private static AtomicBoolean isHappened = new AtomicBoolean(false);
// 请求总数
public static int clientTotal = 5000;
// 同时并发执行的线程数
public static int threadTotal = 200;
public static void main(String[] args) throws Exception {
ExecutorService executorService = Executors.newCachedThreadPool();
final Semaphore semaphore = new Semaphore(threadTotal);
final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
for (int i = 0; i < clientTotal ; i++) {
executorService.execute(() -> {
try {
semaphore.acquire();
test();
semaphore.release();
} catch (Exception e) {
log.error(“exception”, e);
}
countDownLatch.countDown();
});
}
countDownLatch.await();
executorService.shutdown();
log.info(“isHappened:{}”, isHappened.get());
}
private static void test() {
if (isHappened.compareAndSet(false, true)) {
log.info(“execute”);
}
}
}
返回结果:
15:04:54.954 [pool-1-thread-2] INFO com.mmall.concurrency.example.atomic.AtomicBooleanExample - execute
15:04:54.971 [main] INFO com.mmall.concurrency.example.atomic.AtomicBooleanExample - isHappened:true
这里我们发现log.info("execute");
,在代码中只执行了一次,并且isHappened:true
的值为true,这是为啥呢?
这里是因为当程序第一次compareAndSet()
的时候,使得isHappend
变为了true,因为原子性的关系,没有其他线程进行干扰,通过使用AtomicBoolean,我们使某段代码只执行一次。
3.1.4、AtomicReference
AtomicReference
和AtomicInteger
非常类似,不同之处就在于AtomicInteger
是对整数的封装,底层采用的是compareAndSwapInt
实现CAS,比较的是数值是否相等,而AtomicReference
则对应普通的对象引用,底层使用的是compareAndSwapObject
实现CAS,比较的是两个对象的地址是否相等。也就是它可以保证你在修改对象引用时的线程安全性。
多个线程之间的操作无论采用何种执行时序或交替方式,都要保证不变性条件不被破坏,要
保持状态的一致性,就需要在单个原子操作中更新相关的状态变量。
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.atomic.AtomicReference;
@Slf4j
public class AtomicReferenceExample {
private static AtomicReference count = new AtomicReference<>(0);
public static void main(String[] args) {
count.compareAndSet(0, 2);
count.compareAndSet(0, 1);
count.compareAndSet(1, 3);
count.compareAndSet(2, 4);
count.compareAndSet(3, 5);
log.info(“count:{}”, count.get());
}
}
大家觉得我们输出的结果会是多少?
返回结果:
15:26:59.680 [main] INFO com.mmall.concurrency.example.atomic.AtomicReferenceExample - count:4
给大家的福利
零基础入门
对于从来没有接触过网络安全的同学,我们帮你准备了详细的学习成长路线图。可以说是最科学最系统的学习路线,大家跟着这个大的方向学习准没问题。
同时每个成长路线对应的板块都有配套的视频提供:
因篇幅有限,仅展示部分资料
网络安全面试题
绿盟护网行动
还有大家最喜欢的黑客技术
网络安全源码合集+工具包
所有资料共282G,朋友们如果有需要全套《网络安全入门+黑客进阶学习资源包》,可以扫描下方二维码领取(如遇扫码问题,可以在评论区留言领取哦)~
网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!