Java并发--线程安全性
1、主要内容
2、基础知识讲解
3、线程安全性
1、主要内容
2、基础知识讲解
2.1 CPU多级缓存
缓存一致性 MESI
2.2 Java内存模型(JMM)
3、线程安全性
3.1 原子性-Atomic包 package java.util.concurrent.atomic;
给定一个模拟并发访问的例子,不做任何的处理
CountExample1@Slf4j @NotThreadSafe public class CountExample1 { // 请求总数 public static int clientTotal = 5000; // 同时并发执行的线程数 public static int threadTotal = 200; public static int count = 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); } private static void add() { count++; } }这里面模拟共有5000个请求,并发请求是200个,然后一次请求就将count加一,运行的话会发现count的值比5000小
现在我们对上面代码进行修改,将count进行原子性
@Slf4j @NotThreadSafe public class AtomicExample1 { // 请求总数 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); } private static void add() { count.incrementAndGet(); // count.getAndIncrement(); } }这里count是AtomicInteger类型,我们使用了incrementAndGet()这个方法,这里进行源码分析:
incrementAndGet()调用了unsafe类的getAndAddInt()方法,三个参数分别是count自身,count当前值,加法运算的加数
我们继续查看getAndAddInt()的源码
主体实现是do...while...,这里的getIntVolatile()方法是native方法,它是从主内存中获取count所代表的数的值;然后是compareAndSwapInt()方法,也是native方法,该方法先会取得var2的值,然后比较var2与var5,也就是当前线程工作内存中的count值 与 主内存中的值,如果相等,就将var5 + var4(也就是1),赋值给工作内存;否则,重新取var5,var2比较。然后返回var5,旧值。
CAS
1)AtomicIntegerFiledUpdater类
该类的核心作用是原子性更新一个类指定的一个字段的值,该字段必须是volatile修饰,且非static
AtomicIntegerFieldUpdater@Slf4j @ThreadSafe public class AtomicExample2 { private static AtomicIntegerFieldUpdater<AtomicExample2> updater = AtomicIntegerFieldUpdater.newUpdater(AtomicExample2.class, "count"); @Getter public volatile int count = 100; public static void main(String[] args) { AtomicExample2 example2 = new AtomicExample2(); if(updater.compareAndSet(example2, 100, 120)) { log.info("success, count:{}", example2.getCount()); } if(updater.compareAndSet(example2, 100, 120)) { log.info("success, count:{}", example2.getCount()); } else { log.info("failed, count:{}", example2.getCount()); } } }2)AtomicStampedReference类
解决CAS的ABA问题。什么是ABA问题,就是一个线程1在拿线程中的当前值为A与主内存的值比较的时候,另一个线程2已经将该主存中的值改为B又改回了A,导致线程1的比较成立。但这跟不符合CAS的设计。
所以我们在一个值每次进行修改的时候,加一个版本号,也就是Stamp,每次再加一个版本号的比较,解决此问题。
3) AtomicBoolean类
保证一段代码只执行一次
private static AtomicBoolean isHappened = new AtomicBoolean(false); if(isHappened.compareAndSet(false, true)) { // 执行的代码 }
3.2 原子性--synchronized 同步,关键字
作用于调用的对象,表示是某一个对象。
3.3 可见性 一个线程对主内存的修改可以及时的被其他线程观察到
解决方法可以用上面提到的synchronized
还可以使用volatile 关键字
volatile变量在每次被线程访问时,都强迫从主内存中读取该变量的值,在该变量发生变化的时候,会强迫线程将最新的值刷新到主内存。
所以的操作是指令级别的,只需要了解即可
volatile的使用场景:状态标记量
3.4 有序性
如果两个操作的执行顺序无法从happens-before原则推导出来,就无法保证他们的有序性,JVM就可以对其进行重排序