探索 java 中的各种锁

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();
    }
}

说明:

 

小结

探索 期间,遇到了 AbstractQueuedSynchronizer、Unsafe 等,还需要进一步探索(看更多博文呗)。

整个 java.util.concurrent.locks 包 下的内容:

 

疑问:

有了这些锁机制,为什么还需要 class CountDownLatch、class CyclicBarrier、class Semaphore 等呢?它们和 多线程开发 有什么关系?

还有就是 java.util.concurrent.atomic 下的东西。

 

---END---

 

本文链接:

https://www.cnblogs.com/luo630/p/18445669/java-locks-note

 

参考资料

1、java里的锁总结(synchronized隐式锁、Lock显式锁、volatile、CAS)
https://www.cnblogs.com/lifegoeson/p/13683785.html
posted @ 2020-09-17 10:38  Life_Goes_On

2、深入了解Java中的锁机制
2024-03-04
https://developer.aliyun.com/article/1449639

3、一文彻底搞懂面试中常问的各种“锁”
https://www.cnblogs.com/coding-night/p/10657892.html
posted on 2019-04-05 08:24  深夜里的程序猿

4、

 

ben发布于博客园

ben发布于博客园

 

posted @   快乐的欧阳天美1114  阅读(10)  评论(0编辑  收藏  举报
相关博文:
阅读排行:
· DeepSeek “源神”启动!「GitHub 热点速览」
· 我与微信审核的“相爱相杀”看个人小程序副业
· 微软正式发布.NET 10 Preview 1:开启下一代开发框架新篇章
· C# 集成 DeepSeek 模型实现 AI 私有化(本地部署与 API 调用教程)
· spring官宣接入deepseek,真的太香了~
点击右上角即可分享
微信分享提示