网易Java研发面试官眼中的Java并发——安全性、活跃性、性能

最新推荐文章于 2025-10-06 16:31:48 发布

转载最新推荐文章于 2025-10-06 16:31:48 发布 · 103 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：https://www.jianshu.com/p/9030beba5380

文章标签：

#并发 #Java #后端开发 #架构师 #程序人生

Java 专栏收录该内容

185 篇文章

订阅专栏

本文深入探讨了并发编程中常见的三大挑战：安全性问题（数据竞争、竟态条件）、活跃性问题（死锁、活锁、饥饿）及性能问题。通过具体实例分析，介绍了线程安全的重要性及其解决方案，如锁、无锁算法等。

一. 安全性问题

线程安全的本质是正确性，而正确性的含义是程序按照预期执行
理论上线程安全的程序，应该要避免出现可见性问题（CPU缓存）、原子性问题（线程切换）和有序性问题（编译优化）
需要分析是否存在线程安全问题的场景：存在共享数据且数据会发生变化，即有多个线程会同时读写同一个数据
针对该理论的解决方案：不共享数据，采用线程本地存储（Thread Local Storage，TLS）；不变模式

Ⅰ. 数据竞争

数据竞争（Data Race）：多个线程同时访问同一数据，并且至少有一个线程会写这个数据

1. add

private static final int MAX_COUNT = 1_000_000;
private long count = 0;
// 非线程安全
public void add() {
	int index = 0;
	while (++index < MAX_COUNT) {
		count += 1;
	}
}

2. add + synchronized

private static final int MAX_COUNT = 1_000_000;
private long count = 0;
public synchronized long getCount() {
	return count;
}
public synchronized void setCount(long count) {
	this.count = count;
}
// 非线程安全
public void add() {
	int index = 0;
	while (++index < MAX_COUNT) {
		setCount(getCount() + 1);
	}
}

假设count=0，当两个线程同时执行getCount()，都会返回0
两个线程执行getCount()+1，结果都是1，最终写入内存是1，不符合预期，这种情况为竟态条件

Ⅱ. 竟态条件

竟态条件（Race Condition）：程序的执行结果依赖于线程执行的顺序
在并发环境里，线程的执行顺序是不确定的
- 如果程序存在竟态条件问题，那么意味着程序的执行结果是不确定的

1. 转账

public class Account {
	private int balance;
	// 非线程安全，存在竟态条件，可能会超额转出
	public void transfer(Account target, int amt) {
		if (balance > amt) {
			balance -= amt;
			target.balance += amt;
		}
	}
}

Ⅲ. 解决方案

面对数据竞争和竟态条件问题，可以通过互斥的方案来实现线程安全，互斥的方案可以统一归为锁

二. 活跃性问题

活跃性问题：某个操作无法执行下去，包括三种情况：死锁、活锁、饥饿

Ⅰ. 死锁

发生死锁后线程会相互等待，表现为线程永久阻塞
解决死锁问题的方法是规避死锁（破坏发生死锁的条件之一）
- 互斥：不可破坏，锁定目的就是为了互斥
- 占有且等待：一次性申请所有需要的资源
- 不可抢占：当线程持有资源A，并尝试持有资源B时失败，线程主动释放资源A
- 循环等待：将资源编号排序，线程申请资源时按递增（或递减）的顺序申请

Ⅱ. 活锁

活锁：线程并没有发生阻塞，但由于相互谦让，而导致执行不下去
解决方案：在谦让时，尝试等待一个随机时间（分布式一致算法Raft也有采用）

Ⅲ. 饥饿

饥饿：线程因无法访问所需资源而无法执行下去
- 线程的优先级是不相同的，在CPU繁忙的情况下，优先级低的线程得到执行的机会很少，可能发生线程饥饿
- 持有锁的线程，如果执行的时间过长（持有的资源不释放），也有可能导致饥饿问题
解决方案
- 保证资源充足
- 公平地分配资源（公平锁） – 比较可行
- 避免持有锁的线程长时间执行

三. 性能问题

锁的过度使用可能会导致串行化的范围过大，这会影响多线程优势的发挥（并发程序的目的就是为了提升性能）
尽量减少串行，假设串行百分比为5%，那么多核多线程相对于单核单线程的提升公式（Amdahl定律）
S=1/((1-p)+p/n)，n为CPU核数，p为并行百分比，(1-p)为串行百分比

假如p=95%，n无穷大，加速比S的极限为20，即无论采用什么技术，最高只能提高20倍的性能

Ⅰ. 解决方案

无锁算法和数据结构
- 线程本地存储（Thread Local Storage，TLS）
- 写入时复制（Copy-on-write）
- 乐观锁
- JUC中的原子类
- Disruptor（无锁的内存队列）
减少锁持有的时间，互斥锁的本质是将并行的程序串行化，要增加并行度，一定要减少持有锁的时间
- 使用细粒度锁，例如JUC中的ConcurrentHashMap（分段锁）
- 使用读写锁，即读是无锁的，只有写才会互斥的