JAVA 并发与高并发知识笔记(二)

最新推荐文章于 2025-03-30 19:48:14 发布

米斯特程序猿

最新推荐文章于 2025-03-30 19:48:14 发布

阅读量472

点赞数

分类专栏：高并发并发 JAVA

本文链接：https://blog.youkuaiyun.com/keplerpig/article/details/79885760

版权

JAVA 同时被 3 个专栏收录

58 篇文章

订阅专栏

高并发

6 篇文章

订阅专栏

并发

3 篇文章

订阅专栏

本文深入探讨了并发编程的基础概念，包括并发安全与不安全的区别、常用的并发模拟工具及代码实现、线程安全性的定义与体现、CAS原理及其优缺点、解决ABA问题的方法、以及Atomic类的应用示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、并发安全、不安全描述

安全：多个线程操作同一个资源，最后的执行结果与单线程执行结果一致，则说明是线程安全的

不安全：多个线程操作同一个资源，最后执行结果不确定的，则说明不是线程安全的

这里我觉得还是解释一下并发与并行的一点区别比好(并非绝对概念)，并发通常是多个线程去竞争相同资源，而并行通常是多个线程之间是协作关系，例如，在秒杀场景下，多个用户(线程)共同争抢某个资源，这个是并发。例如，多个线程统计一个几千万数据的文件，这个时候线程之间是协作关系，每个线程各自统计分配的一段数据，最后汇总给主线程。

二、常见并发模拟工具以及代码模拟并发(工具使用之后再单独学习)

a) Postman ：http 请求模拟工具

b) AB (Apache Bench) :Apache 附带的模拟工具，主要用来测试网站性能

c) JMeter ： Apache 组织开发的压力测试工具

d) 使用 CountDownLatch、Semaphore 进行并发模拟 (在笔记一中已经提到)

三、代码模拟并发

a) CountDownLatch 介绍：该类为一个计数器，字面意思就是向下减的一个闭锁类

上图解释：

TA 为主线程，主线程初始化 CountDownLatch 计数器为3，T1~3 为子线程，主线程调用CountDownLatch的 await 后就开始阻塞，直到T1~3 调用 CountDownLatch 的 countDown() 方法将计数器减为0，然后主线程继续运行。

b) Semaphore 介绍：

字面意思是信号量，它可以控制同一时间内有多少个线程可以执行，比如我们常见的马路，有4车道，8车道，可以把这里的车道比作线程，4车道相当于4个线程同时执行，8车道想相当于8个线程执行。semaphore 就是好比是这个车道，可以指定有多个车道，从对信号量的功能描述，可以想到在实际开发中可以用来限制同一时间请求接口的次数，通常semaphore 会与线程池配合使用。

c) 并发模拟代码(Not thread safe)

/**
 * 并发模拟
 * 
 * @author Aaron
 *
 */
@NotThreadSafe
@Slf4j
public class ConcurrencyTest1 {

	// 模拟 1000个用户请求
	private final static int TotalClient = 1000;

	// 限制同一时间只能有10个线程执行
	private final static int TotalThread = 10;
	// 计数器
	private static int count = 0;

	public static void main(String[] args) throws InterruptedException {
		ExecutorService es = Executors.newCachedThreadPool();
		// 设置信号量，允许同时最多执行的线程数
		final Semaphore sp = new Semaphore(TotalThread);
		final CountDownLatch cdl = new CountDownLatch(TotalClient);
		for (int i = 0; i < TotalClient; i++) {
			es.execute(new Runnable() {
				@Override
				public void run() {
					try {
						sp.acquire();
						add();
						sp.release();
					} catch (InterruptedException e) {
						log.error("A", e);
					}
					cdl.countDown();
				}
			});
		}
		// 中断主线层代码，直至countdownlatch 的计数器变为0
		cdl.await();
		es.shutdown();
		log.info(String.valueOf(count));
	}

	@NotThreadSafe
	public static void add() {
		count++;
	}

}

d ) 并发模拟daim(Thread safe)

/**
 * 并发模拟
 * 
 * @author Aaron
 *
 */
@ThreadSafe
@Recommend
@Slf4j
public class ConcurrencyTest2 {

	// 模拟 1000个用户请求
	private final static int TotalClient = 1000;

	// 限制同一时间只能有10个线程执行
	private final static int TotalThread = 10;

	// 使用原子类
	private final static AtomicInteger count = new AtomicInteger(0);

	public static void main(String[] args) throws InterruptedException {
		ExecutorService es = Executors.newCachedThreadPool();
		// 设置信号量，允许同时最多执行的线程数
		final Semaphore sp = new Semaphore(TotalThread);
		final CountDownLatch cdl = new CountDownLatch(TotalClient);
		for (int i = 0; i < TotalClient; i++) {
			es.execute(new Runnable() {
				@Override
				public void run() {
					try {
						sp.acquire();
						add();
						sp.release();
					} catch (InterruptedException e) {
						log.error("A", e);
					}
					cdl.countDown();
				}
			});
		}
		// 中断主线层代码，直至countdownlatch 的计数器变为0
		cdl.await();
		es.shutdown();
		log.info(String.valueOf(count.get()));
	}

	@ThreadSafe
	public static void add() {
		count.incrementAndGet();
	}

}

四、类的线程安全性定义

当多个线程同时访问一个类时，不管运行时环境采用何种方式调用或者这些线程如何交替执行，并且在主调代码中不需要做额外的同步或协同操作，这个类始终表现出正确的行为，那么这个类就是线程安全的。

五、线程安全的主要体现点

a) 原子性：

原子性可以解释为互斥性访问，既同一时刻，只能有一个线程进行操作

b) 可见性：

某个线程对主内存的修改，其它线程必须能及时观察到

c) 有序性：

某个线程观察其它线程中的指令执行顺序，由于指令重排序的存在，通常观察到的是杂乱无序的

六、CAS 原理 (以 AtomicInteger 为参考)

由于学习发现我的 eclipse 看不到 unsafe 源码，其它源码可以看到，所以特意安装了反编译插件（Decompiler）

地址：https://www.cnblogs.com/godtrue/p/5499785.html

a ) CAS 是 unsafe 中的 compareAndSwapInt 方法的缩写

b) 原理，在 AtomicInteger 的 incrementAndGet 方法里调用了 unsafe 中的 getAndAddInt 方法，在该方法中，核心的方法是 compareAdnSwapInt 方法，核心原理是通过对象以及值的内存地址取出当前值，然后再进行比较，如果比较是值发生了更改则重新取出最新的值再继续比较，直到比较成功，然后更新值。

// 标记为 native 的方法，说明不是用java实现的，通常是由C、C++ 等等实现的
// 第一个参数是当前对象，第二个参数是值所对应的内存地址
public native int getIntVolatile(Object arg0, long arg1);

// 也是标记为 native 的方法，也是核心方法
// 第一个参数是当前对象，第二个参数是值所对应的内存地址，第三个参数为内存值，第四个参数为准备更新的值
public final native boolean compareAndSwapInt(Object arg0, long arg1, int arg3, int arg4);

// AtomicInteger 中调用的是该方法
// 第一个参数是当前对象，第二个参数是值的内存地址，第三个参数为增加量
public final int getAndAddInt(Object arg0, long arg1, int arg3) {
	int arg4;
	do {
            // 取出当前内存值(预期值)
	     arg4 = this.getIntVolatile(arg0, arg1);
            // 比较当前内存值是否与预期值相等，如果不相等则继续比较，如果相等则返回当前的内存值
            // 如果预期值 与 arg1 指向的值一样，则更新为 arg4 + arg3 
            // 如果不一样则继续循环，直到完成更新
	} while (!this.compareAndSwapInt(arg0, arg1, arg4, arg4 + arg3));

	return arg4;
}

c) CAS 缺点

分析CAS源码后可以发现，如果大量线程进行CAS操作，那么竞争就会很激烈，导致一部分线程由于总是比较失败而长时间停留在循环体中，可能会有瞬间或一段时间的CPU过载，影响系统性能。

d) (JDK1.8 新增 ) LongAdder 与 DoubleAdder 处理思想

对于普通类型的 long 或 double 类型的变量，JVM 允许将64位的读操作或写操作拆分成两个32位的读写操作，该处理方式的主要思想是将热点数据分离，将内部 Value 分离成一个Cell 数组，当多个线程访问时通过HASH等算法将线程映射到其中一个Cell 上进行操作，最终的计算结果则是Cell 数组的求和值，当低并发的时候，算法会直接更新变量的值，在高并发的时候通过分散操作Cell 提高性能，当然缺点也是有的，当并发更改以及调用sum操作时，sum统计的值可能不准确，以下是原话。

    /**
     * Returns the current sum.  The returned value is <em>NOT</em> an
     * atomic snapshot; invocation in the absence of concurrent (意思是在非并发的情况下使用)
     * updates returns an accurate result, but concurrent updates that
     * occur while the sum is being calculated might not be
     * incorporated.
     *
     * @return the sum
     */
    public long sum() {
        Cell[] as = cells; Cell a;
        long sum = base;
        if (as != null) {
            for (int i = 0; i < as.length; ++i) {
                if ((a = as[i]) != null)
                    sum += a.value;
            }
        }
        return sum;
    }

七、java.util.concurrent.atomic 包

八、AtomicReference 与 AtomicIntegerFieldUpdater

a) AtomicReference 基本使用

该类提供一个泛型参数，用于对多种对象的原子操作(注意是对象的操作，如果传入原子类，则是对这个原子类本身的原子操作，并非是原子类中数据的原子操作)，以下为简单的示例

@ThreadSafe
@Slf4j
public class AtomicReferenceTest {

	private static AtomicReference<Integer> ar = new AtomicReference<Integer>(0);

	public static void main(String[] args) {
		// 比较更新方法，如果是值是0，则更新为1
		log.info("{} -> {} - {}", 0, 1, ar.compareAndSet(0, 1));
		// 获取原先的值，并设置为指定的新值
		log.info("{} -> {}", ar.getAndSet(3), ar.get());
		
		// 以下是源码实现，核心还是使用的Unsafe类的方法
		// /**
		// * Atomically sets the value to the given updated value
		// * if the current value {@code ==} the expected value.
		// * @param expect the expected value
		// * @param update the new value
		// * @return {@code true} if successful. False return indicates that
		// * the actual value was not equal to the expected value.
		// */
		// public final boolean compareAndSet(V expect, V update) {
		// native 原子方法
		// return unsafe.compareAndSwapObject(this, valueOffset, expect,
		// update);
		// }
	}
}

b) AtomicIntegerFieldUpdater
基本使用

该类提供一个泛型参数，用于对对象内部的成员变量进行原子操作，以下为简单的示例

@Slf4j
public class AtomicIntegerFieldUpdaterTest {
	private static AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a = AtomicIntegerFieldUpdater
			.newUpdater(AtomicIntegerFieldUpdaterTest.class, "value");
	// 变量必须是 int 基本类型，不能是对象类型
	// 变量必须有 volatile 关键字修饰
	// 以下是源码中的判断
	// if (field.getType() != int.class)
	// throw new IllegalArgumentException("Must be integer type");
	//
	// if (!Modifier.isVolatile(modifiers))
	// throw new IllegalArgumentException("Must be volatile type");
	@Getter
	// 未初始化默认是0
	private volatile int value;

	public static void main(String[] args) {

         AtomicIntegerFieldUpdaterTest aifu = new AtomicIntegerFieldUpdaterTest();
          // 比较&设置
	 a.compareAndSet(aifu, 0, 2);
         log.info("{}", aifu.getValue());
}

}九、解决 CAS 的ABA问题

a) ABA问题解释：

当多个线程操作一个资源时，T1取出值A，T2线程也取出值A，这个时候T2执行过程中将A变为B又变回A，然后T1继续执行发现与自己的值相同，然后进行了更新操作，操作虽然成功，但是这个过程却是有隐患的，比如对一个单项链表操作，T1 取出栈顶A与下一个栈B，想用CAS替换栈顶A为B，在T1执行CAS操作之前，这时候T2取出A和B，然后push了A、C、D，这个时候B属于独立的链表，处于游离状态(当前有两个链表 A->C->D->NULL ,还有一个游离的 B->NULL)，然后T1开始执行CAS操作，发现ACD栈顶还是A，然后开始处理，由于之前已经取出B，当时的B->NULL 这样的，最后结果是把T2的 CD 给丢了。

b) 为了解决ABA问题，有了 AtomicStampedReference 这个类

该类的核心思想是，每次操作都有个一 version 来记录，例如 T2 取出A时版本是 1，更新为B后版本号变为2，再更新为A时版本号变为3，此时由于有版本号控制，T1 再来更新A时发现自己的版本号1 与 3 不一致，最后CAS操作失败。

示例：

@Slf4j
public class ABATest {
	// 普通原子类
	private static AtomicInteger atomicInt = new AtomicInteger(100);
	// 有版本号的实现(参数是初始值与初始版本号)
	private static AtomicStampedReference<Integer> atomicStampedRef = new AtomicStampedReference<Integer>(100, 0);

	public static void main(String[] args) throws InterruptedException {
		// 模拟 B->A
		Thread intT1 = new Thread(new Runnable() {
			@Override
			public void run() {
				// A->B
				atomicInt.compareAndSet(100, 101);
				// B->A
				atomicInt.compareAndSet(101, 100);
			}
		});
		// 模拟 A->B
		Thread intT2 = new Thread(new Runnable() {
			@Override
			public void run() {
				try {
					// 线程休眠，给 T1 执行
					TimeUnit.SECONDS.sleep(1);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				// A->B
				boolean c3 = atomicInt.compareAndSet(100, 101);
				log.info("一般 CAS={}", c3);// 操作成功
			}
		});

		intT1.start();
		intT2.start();
		intT1.join();
		intT2.join();

		Thread refT1 = new Thread(new Runnable() {
			@Override
			public void run() {
				try {
					TimeUnit.SECONDS.sleep(1);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				// A-B 版本号 1
				atomicStampedRef.compareAndSet(100, 101, atomicStampedRef.getStamp(), atomicStampedRef.getStamp() + 1);
				// B-A 版本号 2
				atomicStampedRef.compareAndSet(101, 100, atomicStampedRef.getStamp(), atomicStampedRef.getStamp() + 1);
			}
		});

		Thread refT2 = new Thread(new Runnable() {
			@Override
			public void run() {
				// T2取出版本号
				int stamp = atomicStampedRef.getStamp();
				log.info("有版本号，线程休眠之前:stamp={}", stamp);
				try {
					// 休眠2秒
					TimeUnit.SECONDS.sleep(2);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				// T1 的版本号
				log.info("有版本号，线程休眠之后:stamp={}", atomicStampedRef.getStamp());
				// A->B ，T1 将版本号增加到了2，然后执行时由于T2
				// 持有的版本号还是之前的0，与当前的版本号2不一致，最中CAS操作失败
				boolean c3 = atomicStampedRef.compareAndSet(100, 101, stamp, stamp + 1);
				log.info("有版本号 CAS={}", c3);
			}
		});

		refT1.start();
		refT2.start();
	}

十、 AtomicBoolean 示例

可以使用该类来保证某项操作只执行一次

@Slf4j
public class AtomicBooleanTest {

	private static AtomicBoolean ab = new AtomicBoolean(true);

	public static void main(String[] args) throws InterruptedException {
		ExecutorService es = Executors.newCachedThreadPool();
		int c = 1000;
		int s = 100;
		final Semaphore sh = new Semaphore(s);
		final CountDownLatch cdl = new CountDownLatch(c);
		for (int i = 0; i < c; i++) {
			es.execute(new Runnable() {
				@Override
				public void run() {
					try {
						sh.acquire();
						init();
						sh.release();
					} catch (InterruptedException e) {
						log.error("Error", e);
					}

					cdl.countDown();
				}
			});
		}

		cdl.await();
		es.shutdown();
	}

	private static void init() {
		// 个人理解这么写会有效率问题，因为每次都要进行CAS比较,应该加一层 if 判断,如 init2
		if (ab.compareAndSet(true, false)) {
			log.info(".......init.....OK");
		}
	}

	private static void init2() {
		if (ab.get()) {
			if (ab.compareAndSet(true, false)) {
				log.info(".......init.....OK");
			}
		}
	}
}