java中的锁

🕗 发布于 2024-07-21 04:18 java 开发语言

Lock接口

在Lock接口出现之前，java只靠synchronized来实现锁功能。
Lock接口虽然没有了synchronized隐式获得锁的便捷，但是却拥有了锁获取和释放的可操作性，可中断地获取锁以及超时获取锁的synch不具备的同步特性

相比之下，sychronized关键字则在以下几方面存在局限性：

隐式锁获取和释放：synchronized块和方法隐式地获取和释放锁，程序员无法显式地控制锁的生命周期。
不可中断的锁获取：线程在等待synchronized锁时无法响应中断。
无限期等待：如果一个线程尝试进入synchronized块或方法，而锁被其他线程持有，则会一直等待直到锁被释放。

Lock相比syn的主要优点

尝试非阻塞地获取锁：尝试非阻塞地获取锁意味着线程会尝试立即获取锁，如果锁不可用，线程不会阻塞或等待，而是立即返回一个失败的状态。tryLock()方法被用来尝试获取锁。如果锁可用，它将返回true并获取锁；否则，它将返回false，而不会阻塞线程。
能中断地获取锁：在获取锁的同步队列中可以中断，但线程执行过程中中断不会自动释放锁（finally中释放）。
超时获取锁：超时返回失败

Lock的API

lock（）
当一个线程调用Lock接口的lock()方法时，如果锁当前不可用，线程会进入阻塞（blocking）状态，并被加入同步队列。直到锁被其他线程释放并且轮到该线程获取锁时，它才会从等待状态中恢复并继续执行。
tryLock（）
尝试获取锁，如果锁可用，则获取锁并立即返回true，如果锁不可用，则立即返回false。
unlock（）
lockInterruptibly（）
获取锁，但可以响应中断。如果当前线程在获取锁的过程中被中断，则会抛出InterruptedException。
newCondition（）

队列同步器：AbstractQueuedSynchronizer（AQS）

队列同步器是是用来构建锁或者其他同步组件的基础框架。
同步器的核心成员变量：

abstract class AQS{
private transient volatile Node head;
private transient volatile Node tail;
private volatile int state;
    abstract static class Node {
        volatile Node prev;       // initially attached via casTail
        volatile Node next;       // visibly nonnull when signallable
        Thread waiter;            // visibly nonnull when enqueued
        volatile int status;  
    }
}

一个volatile的状态量state

操作这个volatile的state变量有三种方法：

getState（）
setState（int newState)
compareAndSetState(int expect ,int update)

一个Node构成的双向list队列（同步队列）

这个list队列使用 CAS（Compare-And-Swap）原子地更新队头队尾元素，而不是阻塞队列。
同步队列的实现：
如果一个线程获取同步失败后，会将当前线程以及等待状态等信息构成一个节点并且将其加入同步队列，同时会阻塞当前线程，只有当它成为首节点并且被唤醒后才能获取同步状态。
线程节点状态信息（即Node中的status）：

cancelled，被取消，即在同步队列中等待的线程超时或者被中断，需要取消。
signal，如果当前节点释放锁后会通知其Node的next节点使其获得锁。
condition，此时节点不在同步队列中，而是处于conditionObject内部类的等待队列中，当被唤醒后，会放入同步队列中。

AQS使用模板方法模式，将具体的实现延迟到继承子类中实现

子类需要利用操作volatile的state的方法和操作同步队列的方法来实现线程管理和同步。
子类需要按需实现的模板方法如下：
具体分为：

独占式地获取和释放同步状态
共享式地获取和释放同步状态
查询同步队列中的线程状态

//以下是需要我们重写的方法
protected boolean tryAcquire(int arg) {
        throw new UnsupportedOperationException();
    }

    protected boolean tryRelease(int arg) {
        throw new UnsupportedOperationException();
    }

    protected int tryAcquireShared(int arg) {
        throw new UnsupportedOperationException();
    }

    protected boolean tryReleaseShared(int arg) {
        throw new UnsupportedOperationException();
    }

    protected boolean isHeldExclusively() {
        throw new UnsupportedOperationException();
    }

  //以下是我们使用自定义的同步器实现子类会直接使用的方法
    public final void acquire(int arg) {
        if (!tryAcquire(arg))
            acquire(null, arg, false, false, false, 0L);
    }

   
    public final void acquireInterruptibly(int arg)
        throws InterruptedException {
        if (Thread.interrupted() ||
            (!tryAcquire(arg) && acquire(null, arg, false, true, false, 0L) < 0))
            throw new InterruptedException();
    }

   
    public final boolean tryAcquireNanos(int arg, long nanosTimeout)
        throws InterruptedException {
        if (!Thread.interrupted()) {
            if (tryAcquire(arg))
                return true;
            if (nanosTimeout <= 0L)
                return false;
            int stat = acquire(null, arg, false, true, true,
                               System.nanoTime() + nanosTimeout);
            if (stat > 0)
                return true;
            if (stat == 0)
                return false;
        }
        throw new InterruptedException();
    }

实现一个两个资源的共享锁

 public class TwinsLock  implements Lock {
    private final Sync sync=new Sync();
    private static class Sync extends AbstractQueuedSynchronizer{
        public Sync(int count){
            if(count<=0){
                throw new IllegalArgumentException("count must large than zero");
            }
            setState(count);
        }

        @Override
        protected int tryAcquireShared(int arg) {
            while(true){
                int current=getState();
                int newState=current-arg;
                if(newState<0||compareAndSetState(current,newState))
                    return newState;
            }
        }

        @Override
        protected boolean tryReleaseShared(int arg) {
            while(true){
                int current=getState();
                int newState=current+arg;
                if(compareAndSetState(newState,current))
                    return true;
            }
        }
    }
    @Override
    public void lock() {
        sync.tryAcquireShared(1);
    }
    

    @Override
    public void unlock() {
        sync.tryReleaseShared(1);
    }
}

公平锁和非公平锁

公平锁：加入同步队列时，会判断一下是否是头节点，如果不是则无法加入同步队列。
非公平锁：在加入同步队列前先抢
相比于公平锁，非公平锁开销更小，更少的上下文切换，保证了更大的吞吐。
非公平锁可能造成饥饿，因为如果一直有加入，那么其他同步队列中的线程就无法获取锁。

读写锁

将volatile变量state做了高低位的拆分，高位写锁，地位读锁。
写锁获取必须没有线程持有读锁。

如何实现阻塞或者唤醒一个线程：LockSupport工具（阻塞，等待状态和就绪互相转）

当aqs阻塞和唤醒时，需要使用LockSupport工具来阻塞和唤醒线程。
在 Java 的 AbstractQueuedSynchronizer (AQS) 中，线程进入阻塞状态和从阻塞状态进入就绪状态的机制主要依赖于 LockSupport 类提供的 park 和 unpark 方法。这些方法通过与底层操作系统的线程调度机制交互，控制线程的阻塞和唤醒。
同步队列和阻塞队列具体的实现都是通过 LockSupport 类的 park 和 unpark 方法来挂起和唤醒线程，但在使用上有一些不同，主要体现在使用场景、触发条件和操作对象上。

Condition接口

顶级父类Object上定义了监视器方法，包含wait（）和notify（）等。这些方法和synch配合可以实现等待/通知模式。
Condition接口也实现了类似Object 的等待/通知模式。
Condition 依赖于 Lock 接口。

监视器需要获取监视器锁，而condition需要获取Lock锁，然后调用Lock.newCondition()获取Condition对象。
object.wait()，condition.await()
object只有一个等待队列，condition可以有多个
都支持释放锁并且进入等待状态，超时等待状态
object上有一个同步队列和一个等待队列，而一个aqs可以有多个等待队列（即有多个condition）

原文地址：https://blog.csdn.net/qq_35693377/article/details/140566774

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：用爱探索盲人户外安全出行：蝙蝠避障，我的贴心伙伴
下一篇：如何让爬虫在管理中优雅地应对错误并实现智能重试

关于selenium元素找不到的问题（Unable to locate element: {“method“:“xpath“,“selector“:“）
过了两周，查看日志发现，裂开了，又不好使了，然后，我重新运行了一遍，想找找问题，结果他又好使了。我真的裂开，裂开了啊，再然后下载页面，发现他会出现两种页面，并且页面源代码完全不同？之前一个任务让用se
阅读更多2024-11-17
iOS 键盘弹出视图精准上移
注意，我们可以自行设置一个适当的buffer,我这里是40，就是输入框距离。1 视图精准位移，需要计算出输入框距离屏幕底部的距离，然后。计算出输入框需要上移的距离，就是整个视图需要上移的距离,键盘有一
阅读更多2024-11-17
Intern大模型训练营（八）：Llamaindex RAG 实践
首先在Intern Studio中申请30% A100的开发机。进入开发机后，创建新的conda环境，命名为llamaindex复制完成后，在本地查看环境。运行conda命令，激活llamaindex
阅读更多2024-11-17
Spring事务管理
Spring事务管理是Spring框架中的一个重要功能，用于管理数据库事务。它提供了一种声明式的方式来管理事务，简化了开发人员的工作。
阅读更多2024-11-17
介绍一下整数在内存的储存形式(c基础)
把整数以二进制形式写出在前面补零(保证32位)把整数以二进制形式写出在前面补零（第一位为符号位负数为1，正数为0。第一位（左）为符号位补1。（即1变为0，0变为1)
阅读更多2024-11-17
Linux驱动开发第2步_“物理内存”和“虚拟内存”的映射
“新字符设备的GPIO驱动”和“设备树下的GPIO驱动”都要用到寄存器地址，使用“物理内存”和“虚拟内存”映射时，非常不方便，而pinctrl和gpio子系统的GPIO驱动，非常简化。因此，要重点学习
阅读更多2024-11-17
LLMs 激活函数篇
LLMs 激活函数
阅读更多2024-11-17
学习python的第十天之数据类型——dict字典
Python 中的字典（Dictionary）是一个非常强大的内置数据类型，它用来存储键值对（key-value pairs）信息。字典是无序的，这意味着它们不会记录你添加键值对的顺序；然而，从 Py
阅读更多2024-11-17
基于Java Springboot校园共享单车
为了节省时间和提高工作效率，越来越多的人选择利用互联网进行线上打理各种事务，然后线上管理系统也就相继涌现。基于这种情况，我们需要这样一个界面简单大方、功能齐全的系统来解决用户问题，满足用户需求。课题主
阅读更多2024-11-17
HashMap面试知识点
HashMap链表的插入的方式是是头插法，在多线程的情况下，容易产生环形链表，查询时就会产生死循环问题。HashMap的插入法改为了尾插法，但是多线程情况下依然会产生一些问题，例如前面说到的put()
阅读更多2024-11-17