CAS&Atomic原子操作详解

一、CAS(Compare And Swap)

1、CAS介绍

CAS原理:假设有三个值,E(旧值)、U(需要更新的值)、V(内存中真实的值),具体参照下图:

CAS&Atomic原子操作详解_第1张图片

作用:解决线程轻微竞争场景,同一时间只有一个线程能进入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属性的偏移量就是12
	int x;
}

打印结果:

12
true
true
false 

3、存在问题

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

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

2)ABA问题

CAS&Atomic原子操作详解_第2张图片

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

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() {
				@Override
				public void run() {
					for (int j = 0; j < 10000; j++) {
						atomicInteger.incrementAndGet();
					}
				}
			};
			thread.start();
			thread.join();
		}
		System.out.println(atomicInteger.get());
	}
}

打印结果:100000 

CAS&Atomic原子操作详解_第3张图片

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);
		// 这里返回原值 实际值是100
		System.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 atomicReference = new AtomicReference();
		atomicReference.set(user1);
		System.out.println(atomicReference.get());
		
		// 都是和AtomicInteger一样 先比较user1,然后设置user2
		atomicReference.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 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)分析

具体实现思想如下图:

CAS&Atomic原子操作详解_第4张图片

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

CAS&Atomic原子操作详解_第5张图片

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

3)自定义计算函数
public class LongAccumulatorTest {

	public static void main(String[] args) throws InterruptedException {
        // 累加 x+y
        LongAccumulator 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();
}

你可能感兴趣的:(并发,jvm,后端)