探索 java 中的各种锁

news/2024/10/3 16:19:59

Java 8+

序章

一直听说 java 的各种锁、（线程）同步机制，一直没有深入探索。

最近多看了几篇博文，算是理解的比较深入一些了，特写本文做个记录。ben发布于博客园

锁是什么？

一种用于多个线程运行时协调的机制。

作用如下：ben发布于博客园

1、用于多线程之间同步，比如，执行顺序先后。

2、确保共享数据安全——堆内存数据、方法区数据、类的变量（static）、实例的变量。

隐式锁 vs 显式锁

1、synchronized 是我了解到的唯一的隐式锁，由 JVM 自行实现。

2、其它的为显式锁，比如，interface Lock、interface ReadWriteLock、class StampedLock 及其实现类。

class ReentrantLock 实现了 interface Lock。ben发布于博客园

synchronized

java 关键字。由JVM实现锁机制。

和 class Object 的 wait()/notify()/notifyAll() 配合使用。

特性：

可重入锁。非公平锁。独享锁。悲观锁。

插个翻译：Reentrant lock. Unfair locks. Exclusive locks. Pessimistic locks.。

随着 JVM 的发展，其锁机制也在逐步变化。ben发布于博客园

偏向锁、轻量级锁、重量级锁、锁膨胀等概念都和它有关，这些概念还涉及 synchronized 底层实现用到的 Java对象头——Monitor。

插个翻译：Biased locks, lightweight locks, heavyweight locks, lock expansion。

参考资料：The Java® Virtual Machine Specification: Java SE 8 Edition （pdf 文档可以去 Java官网下载）

The Java® Language Specification: Java SE 8 Edition

修饰类方法（static），使用 Class 对象关联的 monitor。

修饰实例方法，使用实例 this 对象关联的 monitor。ben发布于博客园

当然，还可以锁定代码块。在 14.19 The synchronized Statement 中有介绍：

interface Lock

方法定义：

实现类：

最出名的就是下面提到的 class ReentrantLock 。

class ReentrantLock

实现了 interface Lock。

底层使用 abstract class AbstractQueuedSynchronizer（#重点）实现。

特性：

可重入锁。默认非公平锁，可以初始化为公平锁。独享锁。悲观锁。

类里面的 NonfairSync 为非公平锁实现，而 FairSync 为公平锁。

单独使用（lock(), unlock()等），可以保证多线程时共享数据安全。

结合 interface Condition 使用，可以控制多线程执行流程。

interface Condition

结构：

await() 类似于 Object 的 wait()，执行后，线程进入阻塞状态。

signal()/signalAll() 类似于 Object 的 notify()/notify()All，唤醒阻塞的线程——一个或所有。

interface ReadWriteLock

适用于读多写少的场景。

提供了两个函数：

class ReentrantReadWriteLock

interface ReadWriteLock 的实现类。

底层使用 abstract class AbstractQueuedSynchronizer（#重点）实现，内部类 Sync。

上面的内部类 ReadLock 和 WriteLock 都是实现了 Lock 接口的：

public static class ReadLock implements Lock, java.io.Serializable{private final Sync sync;
}public static class WriteLock implements Lock, java.io.Serializable {private final Sync sync;
}

类里面的 sync 属性是实现锁机制的关键。

特性：

读锁是共享式，写锁是独享锁（排他锁）。可重入锁。

示例程序（通义千问）：

ReadWriteLockExample.java

 // *** 来自 通义千问 ***
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.HashMap;
import java.util.Map;public class ReadWriteLockExample {private final Map<String, String> map = new HashMap<>();private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();private final ReentrantReadWriteLock.ReadLock readLock = lock.readLock();private final ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();public String get(String key) {readLock.lock();try {return map.get(key);} finally {readLock.unlock();}}public void put(String key, String value) {writeLock.lock();try {map.put(key, value);} finally {writeLock.unlock();}}public void remove(String key) {writeLock.lock();try {map.remove(key);} finally {writeLock.unlock();}}public static void main(String[] args) {ReadWriteLockExample example = new ReadWriteLockExample();// 创建多个读线程for (int i = 0; i < 5; i++) {final int threadId = i;new Thread(() -> {for (int j = 0; j < 10; j++) {String value = example.get("key" + (j % 5));System.out.println("Reader " + threadId + ": key" + (j % 5) + " = " + value);try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}}}, "Reader-" + i).start();}// 创建一个写线程new Thread(() -> {for (int i = 0; i < 10; i++) {example.put("key" + i, "value" + i);System.out.println("Writer: Put key" + i + " = value" + i);try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}, "Writer").start();}
}

程序说明：

class StampedLock

Since: 1.8，Java 8 才开始有的。

参考资料#2 提供了足够多的信息。

适用于读操作远远大于写操作的场景——更胜于前面的 interface ReadWriteLock。

特性：

乐观读锁。

类：

Node 类：

示例程序（通义千问）：

StampedLockExample.java

// 来自 通义千问import java.util.concurrent.locks.StampedLock;
import java.util.HashMap;
import java.util.Map;public class StampedLockExample {private final Map<String, String> map = new HashMap<>();private final StampedLock lock = new StampedLock();public String getOptimistic(String key) {long stamp = lock.tryOptimisticRead();String value = map.get(key);// 检查是否有写操作发生if (!lock.validate(stamp)) {// 升级为悲观读锁stamp = lock.readLock();try {value = map.get(key);} finally {lock.unlockRead(stamp);}}return value;}public String get(String key) {long stamp = lock.readLock();try {return map.get(key);} finally {lock.unlockRead(stamp);}}public void put(String key, String value) {long stamp = lock.writeLock();try {map.put(key, value);} finally {lock.unlockWrite(stamp);}}public void remove(String key) {long stamp = lock.writeLock();try {map.remove(key);} finally {lock.unlockWrite(stamp);}}public static void main(String[] args) {StampedLockExample example = new StampedLockExample();// 创建多个读线程for (int i = 0; i < 5; i++) {final int threadId = i;new Thread(() -> {for (int j = 0; j < 10; j++) {String value = example.getOptimistic("key" + (j % 5));System.out.println("Reader " + threadId + ": key" + (j % 5) + " = " + value);try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}}}, "Reader-" + i).start();}// 创建一个写线程new Thread(() -> {for (int i = 0; i < 10; i++) {example.put("key" + i, "value" + i);System.out.println("Writer: Put key" + i + " = value" + i);try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}, "Writer").start();}
}

说明：