java 标准库中的 hashmap 本身并不提供无锁算法,直接使用它无法实现无锁并发。要提升高并发下的性能并实现无锁(lock-free)效果,应使用 concurrenthashmap。在 jdk 1.8 中,concurrenthashmap 通过 cas(compare-and-swap)操作和 synchronized 关键字实现了细粒度的节点级同步,避免了全局锁竞争。

ConcurrentHashMap 如何避免全局锁
它利用分段思想演进为基于 Node 节点的 CAS + synchronized 机制。当多个线程同时写入时,只有发生哈希冲突的桶(Bucket)才会被锁定,其他桶的操作互不干扰。这种设计显著降低了锁粒度,提升了吞吐量。

import java.util.concurrent.ConcurrentHashMap;
public class LockFreeExample {
public static void main(String[] args) {
ConcurrentHashMap<string integer> map = new ConcurrentHashMap();
// 模拟多线程写入
Thread t1 = new Thread(() -> {
map.put("key1", 1);
System.out.println("Thread 1 put key1");
});
Thread t2 = new Thread(() -> {
map.put("key2", 2);
System.out.println("Thread 2 put key2");
});
t1.start();
t2.start();
try {
t1.join();
t2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Final Map: " + map);
}
}</string>
运行上述代码,两个线程会分别插入不同的键值对。由于 key1 和 key2 通常映射到不同的桶,它们之间几乎没有锁竞争。如果插入相同的键,则只有一个线程能成功更新,另一个线程会重试或覆盖,具体取决于逻辑。最终输出显示两个键值对都已存在。
为什么不用 ReentrantLock 包装 HashMap
使用 ReentrantLock 包装 HashMap 是一种粗粒度的同步方式。虽然它能保证线程安全,但所有访问该 Map 的线程都必须排队获取同一个锁,导致并发度急剧下降,违背了无锁高性能的初衷。相比之下,ConcurrentHashMap 的内部机制允许非冲突区域的并行处理。
使用 Husky 将 pre-commit、pre-push 和 commit-msg 检查集成到仓库中,以便代理和开发人员在更改离开工作站之前运行相同的本地防护措施。

import java.util.HashMap;
import java.util.concurrent.locks.ReentrantLock;
public class LockedMapExample {
private final HashMap<string integer> map = new HashMap();
private final ReentrantLock lock = new ReentrantLock();
public void put(String key, int value) {
lock.lock();
try {
map.put(key, value);
} finally {
lock.unlock();
}
}
public int get(String key) {
lock.lock();
try {
return map.getOrDefault(key, 0);
} finally {
lock.unlock();
}
}
public static void main(String[] args) {
LockedMapExample example = new LockedMapExample();
example.put("test", 100);
System.out.println(example.get("test"));
}
}</string>
这段代码展示了使用 ReentrantLock 保护 HashMap 的典型模式。每次 put 或 get 操作都会获取锁,执行完毕后释放。在高并发场景下,这会导致大量的线程阻塞和上下文切换,性能远不如 ConcurrentHashMap。因此,除非有特殊的业务逻辑需要跨多个操作的原子性,否则应避免这种写法。
CAS 操作在扩容时的具体表现
在 ConcurrentHashMap 扩容时,采用了一种称为“帮助式扩容”的机制。如果一个线程发现 Map 正在扩容,它会暂停自己的操作,转而帮助其他线程完成扩容任务,而不是等待扩容结束。这种设计确保了没有线程会因为扩容而长时间阻塞,进一步体现了无锁/低锁的思想。
Java免费学习笔记:立即使用
解锁 Java 大师之旅:从入门到精通的终极指南










