一、CAS（Compare And Swap）

1、CAS介绍

CAS原理：假设有三个值，E（旧值）、U（需要更新的值）、V（内存中真实的值），具体参照下图：

作用：解决线程轻微竞争场景，同一时间只有一个线程能进入CAS代码块中，其它线程空转循环

compareAndSwapInt()方法对不同系统CAS指令的包装，Intel的汇编指令cmpxchg，不同厂家所实现的具体算法不一样

2、举例

public class UnsafeFactory {/*** 通过反射获取Unsafe属性* @return*/public static Unsafe getUnsafe() {Field theUnsafe;try {theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");theUnsafe.setAccessible(true);// 因为theUnsafe是静态属性 所以field.get(Object)参数传什么都可以return (Unsafe) theUnsafe.get(null);} catch (Exception e) {e.printStackTrace();}return null;}/*** 找到指定类属性在内存中偏移的地址* @param clazz* @param fieldName* @return*/public static long getFieldOffset(Class clazz, String fieldName) {try {return getUnsafe().objectFieldOffset(clazz.getDeclaredField(fieldName));} catch (Exception e) {throw new Error(e);}}
}public class CASTest {public static void main(String[] args) {Entity entity = new Entity();Unsafe unsafe = UnsafeFactory.getUnsafe();long fieldOffset = UnsafeFactory.getFieldOffset(Entity.class, "x");System.out.println(fieldOffset);System.out.println(unsafe.compareAndSwapInt(entity, fieldOffset, 0, 1));System.out.println(unsafe.compareAndSwapInt(entity, fieldOffset, 1, 2));// 这个时候内存中的值已经改成2，所以0改成3是不能改成功的System.out.println(unsafe.compareAndSwapInt(entity, fieldOffset, 0, 3));}
}class Entity {// markword占8字节 klasspointer默认开启指针压缩占4字节 x属性的偏移量就是12int x;
}

打印结果：

12
true
true
false 

3、存在问题

1）激烈竞争线程空转导致性能下降

如果存在大量线程竞争一个变量，必然导致其它线程资源，或者长期CAS失败的线程，都会给CPU调度产生性能问题

2）ABA问题

可以加一个版本号区分究竟做了多少次版本的修改

3）只能对一个值做原子操作

当对一个共享变量执行操作时，我们可以使用循环CAS的方式来保证原子操作，但对多个共享变量操作时，循环CAS无法保证操作的原子性，这个时候可以用锁

二、Atomic原子操作类

1、使用

在java.util.concurrent.atomic包里提供了一组原子操作类：

• 基本类型：AtomicInteger、AtomicLong、AtomicBoolean；
• 引用类型：AtomicReference、AtomicStampedRerence、AtomicMarkableReference；
• 数组类型：AtomicIntegerArray、AtomicLongArray、AtomicReferenceArray
• 对象属性原子修改器：AtomicIntegerFieldUpdater、AtomicLongFieldUpdater、 AtomicReferenceFieldUpdater
• 原子类型累加器（jdk1.8增加的类）：DoubleAccumulator、DoubleAdder、 LongAccumulator、LongAdder、Striped64

1）原子基本类型

public class AtomicIntegerTest {static AtomicInteger atomicInteger = new AtomicInteger();public static void main(String[] args) throws InterruptedException {for (int i = 0; i < 10; i++) {Thread thread = new Thread() {@Overridepublic void run() {for (int j = 0; j < 10000; j++) {atomicInteger.incrementAndGet();}}};thread.start();thread.join();}System.out.println(atomicInteger.get());}
}

打印结果：100000 

incrementAndGet()方法就是通过CAS循环读取AtomicInteger类的value属性在内存中的值，直到加1成功，跳出while循环，返回旧值

2）原子更新数组类型

public class AtomicIntegerArrayTest {static int[] array = {10, 21, 9, 32, 99};static AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(array);public static void main(String[] args) {// 设置下标为0的元素为100
//		atomicIntegerArray.set(0, 100);int andSet = atomicIntegerArray.getAndSet(0, 100);// 这里返回原值 实际值是100System.out.println(andSet);int i = atomicIntegerArray.get(0);System.out.println(i);int andAdd = atomicIntegerArray.getAndAdd(1, 9);// 这里也是一样 返回的是原值 实际是加9之后的值System.out.println(andAdd);int j = atomicIntegerArray.get(1);System.out.println(j);}
}

打印结果：

10
100
21
30 

3）原子更新引用类型

public class AtomicReferenceTest {public static void main(String[] args) {User user1 = new User("张三", 11);User user2 = new User("李四", 18);User user3 = new User("王五", 15);AtomicReference<User> atomicReference = new AtomicReference<User>();atomicReference.set(user1);System.out.println(atomicReference.get());// 都是和AtomicInteger一样 先比较user1，然后设置user2atomicReference.compareAndSet(user1, user2);System.out.println(atomicReference.get());atomicReference.compareAndSet(user1, user3);System.out.println(atomicReference.get());}
}
@Data
@AllArgsConstructor
// 上面两个注解需要lombok插件
class User {private String name;private Integer age;}

打印结果：

User(name=张三, age=11)
User(name=李四, age=18)
User(name=李四, age=18) 

4）对象属性原子修改器

public class AtomicIntegerFieldUpdaterTest {public static class Candidate {volatile int score = 0;AtomicInteger salary = new AtomicInteger();}public static final AtomicIntegerFieldUpdater<Candidate> aifu = AtomicIntegerFieldUpdater.newUpdater(Candidate.class, "score");public static AtomicInteger realScore = new AtomicInteger(0);public static void main(String[] args) throws InterruptedException {final Candidate candidate = new Candidate();Thread[] threads = new Thread[10000];for (int i = 0; i < 10000; i++) {threads[i] = new Thread(() -> {if (Math.random() > 0.4) {candidate.salary.incrementAndGet();aifu.incrementAndGet(candidate);realScore.incrementAndGet();}});threads[i].start();}for (int i = 0; i < 10000; i++) {threads[i].join();}System.out.println("AtomicIntegerFieldUpdater Score="+candidate.score);System.out.println("AtomicInteger salary="+candidate.salary.get());System.out.println("realScore="+realScore.get());}
}

打印结果：

AtomicIntegerFieldUpdater Score=6057
AtomicInteger salary=6057
realScore=6057 

对于AtomicIntegerFieldUpdater 的使用稍微有一些限制和约束，约束如下：

1. 字段必须是volatile类型的，在线程之间共享变量时保证立即可见.eg:volatile int value = 3
2. 字段的描述类型（修饰符public/protected/default/private）与调用者与操作对象字段的 关系一致。也就是说调用者能够直接操作对象字段，那么就可以反射进行原子操作。但是对于父 类的字段，子类是不能直接操作的，尽管子类可以访问父类的字段。
3. 只能是实例变量，不能是类变量，也就是说不能加static关键字。
4. 只能是可修改变量，不能使final变量，因为final的语义就是不可修改。实际上final的语义和 volatile是有冲突的，这两个关键字不能同时存在。
5. 对于AtomicIntegerFieldUpdater和AtomicLongFieldUpdater只能修改int/long类型的字 段，不能修改其包装类型（Integer/Long）。如果要修改包装类型就需要使用AtomicReferenceFieldUpdater。

2、LongAdder/DoubleAdder详解

解决高并发环境下AtomicInteger， AtomicLong的自旋瓶颈问题，引入了LongAdder，LongAdder类是继承Striped64类的

1）使用

/*** LongAdder为了解决高并发情况下自旋瓶颈* 原来的是单个值CAS，LongAdder是先根据base进行CAS，CAS失败再根据CPU线程数创建Cell数组，每个线程操作的是Cell数组的Cell对象value值进行累加，最后进行汇总* 这样就相当于开设了多个共享变量进行CAS操作* @author gaopu* @Time 2023年5月19日 下午3:39:30*/
public class LongAdderTest {public static void main(String[] args) {// 10个线程 每个线程都自增10000次testAtomicLongVSLongAdder(10, 10000);testAtomicLongVSLongAdder(10, 200000);testAtomicLongVSLongAdder(100, 200000);}static void testAtomicLongVSLongAdder(final int threadCount, final int times) {try {long start = System.currentTimeMillis();testLongAdder(threadCount, times);long end = System.currentTimeMillis() - start;System.out.println("线程数："+threadCount+"，单线程操作自增次数："+times+"，LongAdder总自增次数："+(threadCount*times)+"，总耗时:"+end);long start2 = System.currentTimeMillis();testAtomicLong(threadCount, times);long end2 = System.currentTimeMillis() - start2;System.out.println("线程数："+threadCount+"，单线程操作自增次数："+times+"，AtomicLong总自增次数："+(threadCount*times)+"，总耗时:"+end2);} catch (InterruptedException e) {e.printStackTrace();}}static void testAtomicLong(final int threadCount, final int times) throws InterruptedException {CountDownLatch countDownLatch = new CountDownLatch(threadCount);AtomicLong atomicLong = new AtomicLong();for (int i = 0; i < threadCount; i++) {new Thread(() -> {for (int j = 0; j < times; j++) {atomicLong.incrementAndGet();}countDownLatch.countDown();}, "thread"+i).start();}countDownLatch.await();}static void testLongAdder(final int threadCount, final int times) throws InterruptedException {CountDownLatch countDownLatch = new CountDownLatch(threadCount);LongAdder longAdder = new LongAdder();for (int i = 0; i < threadCount; i++) {new Thread(() -> {for (int j = 0; j < times; j++) {longAdder.add(1);}countDownLatch.countDown();}).start();}countDownLatch.await();}
}

打印结果：

线程数：10，单线程操作自增次数：10000，LongAdder总自增次数：100000，总耗时:59
线程数：10，单线程操作自增次数：10000，AtomicLong总自增次数：100000，总耗时:4
线程数：10，单线程操作自增次数：200000，LongAdder总自增次数：2000000，总耗时:14
线程数：10，单线程操作自增次数：200000，AtomicLong总自增次数：2000000，总耗时:40
线程数：100，单线程操作自增次数：200000，LongAdder总自增次数：20000000，总耗时:37
线程数：100，单线程操作自增次数：200000，AtomicLong总自增次数：20000000，总耗时:358
由此可见，随着线程数和自增次数增加， LongAdder的优势就体现出来了

2）分析

具体实现思想如下图：

https://www.processon.com/view/link/64c0dc6ef208ef32d3e43abd

LongAdder的sum()放存在线程不安全问题，调用sum()方法获取的结果不一定就是最终的结果 ，有可能base和Cell类的value属性正在参与运算

3）自定义计算函数

public class LongAccumulatorTest {public static void main(String[] args) throws InterruptedException {// 累加 x+yLongAccumulator accumulator = new LongAccumulator((x, y) -> x + y, 0);ExecutorService executor = Executors.newFixedThreadPool(8);// 2到10累加IntStream.range(2, 11).forEach(i -> executor.submit(() -> accumulator.accumulate(i)));Thread.sleep(2000);System.out.println(accumulator.getThenReset());}
}

打印结果：54

---

---

---

三、并发安全问题

1、线程封闭

就是把对象封装到一个线程里，只有这一个线程能看到此对象。那么这个对 象就算不是线程安全的也不会出现任何安全问题。

1）栈封闭

多个线程访问一个方法，此方法中的局部变量都会被拷贝一份到 线程栈中。所以局部变量是不被多个线程所共享的，也就不会出现并发问题。所 以能用局部变量就别用全局的变量，全局变量容易引起并发问题。     

2）ThreadLocal

ThreadLocal 是实现线程封闭的最好方法。ThreadLocal 内部维护了一个 Map， Map 的 key 是每个线程的名称，而 Map 的值就是我们要封闭的对象。每个线程 中的对象都对应着 Map 中一个值，也就是 ThreadLocal 利用 Map 实现了对象的 线程封闭。   

2、无状态的类

没有任何成员变量的类，就叫无状态的类；方法中含有其它对象导致的线程不安全，那就是方法参数中这个类的问题

3、让类不可变

让状态不可变，加 final 关键字，对于一个类，所有的成员变量应该是私有 的，同样的只要有可能，所有的成员变量应该加上 final 关键字，但是加上 final， 要注意如果成员变量又是一个对象时，这个对象所对应的类也要是不可变，才能 保证整个类是不可变的。

但是要注意，一旦类的成员变量中有对象，上述的 final 关键字保证不可变 并不能保证类的安全性，为何？因为在多线程下，虽然对象的引用不可变，但是 对象在堆上的实例是有可能被多个线程同时修改的，没有正确处理的情况下，对 象实例在堆中的数据是不可预知的。

4、加锁和CAS

我们最常使用的保证线程安全的手段，使用 synchronized 关键字，使用显式 锁，使用各种原子变量，修改数据时使用 CAS 机制等等。

5、死锁

一个锁资源肯定是不会发生死锁，最少是两个线程去争抢两个资源，争抢的顺序不对，并且抢不到就一直抢而导致死锁，在Java中可以通过jps命令，jvisualvm打开可视化界面分析什么原因导致死锁

6、活锁

两个线程在尝试拿锁的机制中，发生多个线程之间互相谦让，不断发生同一 个线程总是拿到同一把锁，在尝试拿另一把锁时因为拿不到，而将本来已经持有 的锁释放的过程（比如A、B两个线程同时进行，A线程尝试拿锁1，B线程尝试拿锁2，此时都要拿对象持有的锁资源，A线程拿不到锁2就释放了锁1，线程B拿不到锁1就释放了锁2，这样一直循环往复就永远相互等待）。

解决办法：每个线程休眠随机数，错开拿锁的时间。

7、线程饥饿

低优先级的线程，总是拿不到执行时间

8、单例模式

1）基于DCL线程安全的懒汉单例模式

public class SingletonTest {private SingletonTest() {}private static volatile SingletonTest singletonTest = null;public static SingletonTest get() {if (singletonTest == null) {synchronized (SingletonTest.class) {// 这里为什么还要判断（DCL双重检查 为了防止等待锁的线程进来没有判断又创建一个对象）if (singletonTest == null) {// java创建对象不是原子的// 1、申请内存空间// 2、对象初始化// 3、指向内存空间的地址// 要加上volatile关键字防止指令重排序返回没有初始化完的对象singletonTest = new SingletonTest();}}}return singletonTest;}public static void main(String[] args) {System.out.println(SingletonTest.get());}
}

2）虚拟机保证线程安全的单例模式

• 懒汉单例模式

public class SingleLazy {private SingleLazy() {}private static class InstanceHolder {// 静态属性在类加载期间就初始化好了private static SingleLazy lazy = new SingleLazy();}public static SingleLazy getInstance() {return InstanceHolder.lazy;}
}

• 饿汉单例模式

public class SingleHungry {private SingleHungry() {}private static SingleHungry hungry = new SingleHungry();
}