在线重定义过程中需要exclusive lock.

最新推荐文章于 2024-03-13 13:11:28 发布
原创 最新推荐文章于 2024-03-13 13:11:28 发布 · 1.5k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#microsoft #table #session #sql #application #database

本文探讨了通过调整Oracle数据库中的DDL_LOCK_TIMEOUT参数来延长DDL操作等待时间的方法，以提高表在线重定义等操作的成功率。

执行DBMS_REDEFINITION.FINISH_REDEF_TABLE 存储过程完成表的在线重定

义。在此procedure运行过程中，原表会被以Exclusive lock mode(TM lmode=6)排他模式锁住

极为短暂的一段时间(秒级)，具体这段时间的长短受到原表上数据量的影响。但有时候应用繁忙时可能不能立刻获得！

那么能不能使用一个参数让它多等待一段时间呢？

下面做个实验看看：

Microsoft Windows [版本 6.1.7601]
版权所有 (c) 2009 Microsoft Corporation。保留所有权利。

C:\Users\ibsadmin>sqlplus / as sysdba

SQL*Plus: Release 11.2.0.1.0 Production on 星期四 8月 16 17:49:47 2012

Copyright (c) 1982, 2010, Oracle.  All rights reserved.


连接到:
Oracle Database 11g Enterprise Edition Release 11.2.0.1.0 - 64bit Production
With the Partitioning, OLAP, Data Mining and Real Application Testing options

SQL> show parameter ddl_lock_timeout

NAME                                 TYPE        VALUE
------------------------------------ ----------- ------------------------------
ddl_lock_timeout                     integer     0
SQL> select A.sid, b.serial#,
  2    decode(A.type,
  3        'MR', 'Media Recovery',
  4        'RT','Redo Thread',
  5        'UN','User Name',
  6        'TX', 'Transaction',
  7        'TM', 'DML',
  8        'UL', 'PL/SQL User Lock',
  9        'DX', 'Distributed Xaction',
 10       'CF', 'Control File',
 11       'IS', 'Instance State',
 12       'FS', 'File Set',
 13       'IR', 'Instance Recovery',
 14       'ST', 'Disk Space Transaction',
 15       'TS', 'Temp Segment',
 16       'IV', 'Library Cache Invalida-tion',
 17       'LS', 'Log Start or Switch',
 18       'RW', 'Row Wait',
 19       'SQ', 'Sequence Number',
 20       'TE', 'Extend Table',
 21       'TT', 'Temp Table',
 22       'Unknown') LockType,
 23   c.object_name,
 24   b.username,
 25   b.osuser,
 26   decode(a.lmode,   0, 'None',
 27               1, 'Null',
 28               2, 'Row-S',
 29               3, 'Row-X',
 30               4, 'Share',
 31               5, 'S/Row-X',
 32               6, 'Exclusive', 'Unknown') LockMode,
 33   B.MACHINE,D.SPID
 34   from v$lock a,v$session b,all_objects c,V$PROCESS D
 35   where a.sid=b.sid and a.type in ('TM','TX')
 36   and c.object_id=a.id1
 37   AND B.PADDR=D.ADDR;

未选定行

在另一个SESSION：

Microsoft Windows [版本 6.1.7601]
版权所有 (c) 2009 Microsoft Corporation。保留所有权利。

C:\Users\ibsadmin>sqlplus / as sysdba

SQL*Plus: Release 11.2.0.1.0 Production on 星期四 8月 16 17:52:55 2012

Copyright (c) 1982, 2010, Oracle.  All rights reserved.


连接到:
Oracle Database 11g Enterprise Edition Release 11.2.0.1.0 - 64bit Production
With the Partitioning, OLAP, Data Mining and Real Application Testing options

SQL> create table t (cloa int);

表已创建。

SQL> insert into t values(1);

已创建 1 行。

 

SQL>

回到原来的session:
SQL> set timing on
SQL> truncate table t;
truncate table t
               *
第 1 行出现错误:
ORA-00054: 资源正忙, 但指定以 NOWAIT 方式获取资源, 或者超时失效


已用时间:  00: 00: 00.10
SQL>  select A.sid, b.serial#,
  2     decode(A.type,
  3         'MR', 'Media Recovery',
  4         'RT','Redo Thread',
  5         'UN','User Name',
  6         'TX', 'Transaction',
  7         'TM', 'DML',
  8         'UL', 'PL/SQL User Lock',
  9         'DX', 'Distributed Xaction',
 10        'CF', 'Control File',
 11        'IS', 'Instance State',
 12        'FS', 'File Set',
 13        'IR', 'Instance Recovery',
 14        'ST', 'Disk Space Transaction',
 15        'TS', 'Temp Segment',
 16        'IV', 'Library Cache Invalida-tion',
 17        'LS', 'Log Start or Switch',
 18        'RW', 'Row Wait',
 19        'SQ', 'Sequence Number',
 20        'TE', 'Extend Table',
 21        'TT', 'Temp Table',
 22        'Unknown') LockType,
 23    c.object_name,
 24    b.username,
 25    b.osuser,
 26    decode(a.lmode,   0, 'None',
 27                1, 'Null',
 28                2, 'Row-S',
 29                3, 'Row-X',
 30                4, 'Share',
 31                5, 'S/Row-X',
 32                6, 'Exclusive', 'Unknown') LockMode,
 33    B.MACHINE,D.SPID
 34    from v$lock a,v$session b,all_objects c,V$PROCESS D
 35    where a.sid=b.sid and a.type in ('TM','TX')
 36    and c.object_id=a.id1
 37    AND B.PADDR=D.ADDR;

       SID    SERIAL# LOCKTYPE                    OBJECT_NAME
---------- ---------- --------------------------- ------------------------------

USERNAME                       OSUSER                         LOCKMODE
------------------------------ ------------------------------ ---------
MACHINE
----------------------------------------------------------------
SPID
------------------------
        31       1615 DML                         T
SYS                            115-DTHVM\ibsadmin             Row-X
WORKGROUP\115-DTHVM
3748


已用时间:  00: 00: 00.18
SQL> alter session set ddl_lock_timeout = 5;

会话已更改。

已用时间:  00: 00: 00.01
SQL> truncate table t;
truncate table t
               *
第 1 行出现错误:
ORA-00054: 资源正忙, 但指定以 NOWAIT 方式获取资源, 或者超时失效


已用时间:  00: 00: 05.01

另一个SESSION提交数据：

回到原来 session执行：
SQL> truncate table t;

表被截断。

已用时间:  00: 00: 03.14
SQL>

虽然不能保证每次都成功，但完全可以增加成功的机率！

 

 

 

 

 

 


 

高薪程序员&面试题精讲系列66之你熟悉Lock锁吗？说说Lock锁的底层原理吧
一一哥
02-21 1137
一. 面试题及剖析 1. 今日面试题 Lock锁有哪些实现类，分别有什么功能？ Lock锁的底层原理如何？ 你的项目中哪里用过可重入锁(ReentrantLock)？ 2. 题目剖析 在上一篇文章中，壹哥给大家介绍了Lock锁的基本特性，接下来我会继续介绍Lock锁的底层原理，这才是我们面试时的重中之重，并且会在本文中分析synchronize与Lock锁的区别。 二. Lock锁的底层原理分析 1. 底层原理(重点) 我们知道Lock是一个接口，平时在使用时，都是使用该接口的某个子类
用户界面的需求分析与设计原则
热门推荐
henrybai的专栏--大亨利白--大码
01-10 4万+
一、引言用户界面是人与计算机之间的媒介。用户通过用户界面来与计算机进行信息交换。因此，用户界面的质量，直接关系到应用系统的性能能否充分发挥，能否使用户准确、高效、轻松、愉快地工作。所以软件的友好性、易用性对于软件系统至关重要。目前国内软件开发者在设计过程中很注重软件的开发技术及其具有的业务功能，而忽略了用户对用户界面的需求，影响软件的易用性、友好性。其实用户界面是一个应用程序很重要的一面——它
深入理解Java并发框架AQS系列（三）：独占锁（Exclusive Lock）
sjzsylkn的专栏
03-24 494
深入理解Java并发框架AQS系列（三）：独占锁（Exclusive Lock） 一、前言 优秀的源码就在那里 经过了前面两章的铺垫，终于要切入正题了，本章也是整个AQS的核心之一 从本章开始，我们要精读AQS源码，拜读它、欣赏它、学习它并质疑它。当然我们的写作风格不会带着大家逐行去看源码（会有“只在此山中，云深不知处”的弊端），而是从功能入手，对其架构进行逐层剖析，在核心位置重点解读，并提出质疑；虽然AQS源码读起来比较“跳”，但我还是建议大家花时间、精力去好好读它 本章我们会采用经典并发类Reent
Oracle blocking issue with lock table in exclusive mode
cuimidiao3147的博客
09-17 253
A PL/SQL program previously worked in serial, but it hung when running in parallel.select ses.SID, substr(SQ.SQL_T...
在线重定义
richard的专栏（bigdata.han@gmail.com）
09-12 690
在线重定义是oracle改变表结构的高可用方案，即在线修改表结构，分为以主键和rowid2种定义方法 它是一个刷新物化视图，瞬间锁表rename的过程，将原表的base数据和更新数据通过物化视图同步到中间表然后rename中间表成原表 注意：1原表索引对应的中间表索引必须为全局，不然会报错             2对应归档的数据库，势必产生大量的归档，重建索引最好加上n
exclusive 和 lock
fgupupup的博客
07-24 4582
exclusive 和lock 1. 首先，Lock在amba2.0中就有涉及，意思是，某个master 可以通过Lock 总线来实现独占。只有当该master完成传输后才释放出总线。这样的话，总线的效率会降低。 2. 相比Lock，AXI 中引入了exclusive操作，不需要将bus锁定给某个master。而是通过TAG ID以及slave 返回的response来判断当前的传输是否成功。过程...
PostgreSQL V9.6 ExclusiveLock的用途
那海蓝蓝的博客
03-13 2171
1 创建劝告锁 pg_advisory_lock_int8(PG_FUNCTION_ARGS) //在指定对象上加派他式的劝告锁 {...             SET_LOCKTAG_INT64(tag, key);             (void) LockAcquire(&tag, ExclusiveLock, true, false); ...} 2 对于诸如
Lock详解.pdf
01-20
3. **手动管理**：ReentrantLock需要手动调用lock()获取锁和unlock()释放锁，相比于synchronized的自动管理，这为开发者提供了更精细的控制。 ReentrantLock的内部实现是通过AQS来完成的。AQS是一个抽象的同步器，...
Oracle DBMS_LOCK
JangBingYang的博客
03-13 1875
开发者可以根据业务逻辑的需要，使用DBMS_LOCK来实现自定义的并发控制策略。例如，在批处理作业中，可能需要确保同一批数据不会被多个作业同时处理。通过DBMS_LOCK，可以为每个批处理作业创建一个唯一的锁，确保在同一时间只有一个作业可以处理该批数据。需要注意的是，虽然DBMS_LOCK提供了强大的并发控制功能，但也需要谨慎使用。不恰当地使用锁可能会导致死锁、性能下降等问题。因此，在使用DBMS_LOCK时，应该仔细规划锁的策略，并确保在适当的时候释放锁。
Lock锁—lock方法源码分析（锁获取）
bc_Reversing的博客
03-17 922
Lock锁是jdk1.5中引入的java线程安全与同步机制。 java.util.concurrent.locks包下常用的类与接口 我们都知道java中锁的出现是为了解决多线程情况下，线程的安全与同步问题，所谓的“线程同步机制”就是一套哦用于协调线程间的数据访问（Data Access）和活动（Activity）的机制，该机制在保证线程安全的同时，实现这些线程的共同目标。 我们都知道在多个线程并发访问共享数据的时候会产生线程安全的问题，如何在多个线程并发的时候保证线程的安全的呢？...
Java Lock源码总结 Lock源码注释翻译和解析中英文对照版
weixin_45754452的博客
09-28 502
版本 JDK8(JDK1.8) Lock接口源码重点 1.Lock实现提供了比使用synchronized方法和语句更广泛的锁操作。它们允许更灵活的结构，可能具有完全不同的属性，并且可能支持多个关联的Condition对象。 2.随着灵活性的提高，还需要承担更多的责任。由于没有synchronized块结构锁，因此方法和语句不会自动释放锁。在大多数情况下，应使用以下模式： Lock l = ...; l.lock(); try { // 访问受此锁保护的资源 } finally {
WARNING: you don't own a lock of type ExclusiveLock
kmblack1的专栏
03-31 1361
咨询锁出现下列警告 WARNING: you don't own a lock of type ExclusiveLock 原因:试图释放锁的次数超过锁定的次数。 问题重现:锁定了一次,但释放了两次所以出现“WARNING: you don’t own a lock of type ExclusiveLock” with cte as( select pg_advisory_l...
锁表机制{转载}
SAP Blog——SAP Explorer
10-21 644
SAP的一大特点，就是可以设置Batch Job，定时定量跑程序。    但是这样就会碰到一个问题，会出现多个Batch job读写的情况。如果仅仅是读或是写的话，还好，最多是数据库延迟。但是如果对一个表，即读又写的话，就会产生数据一致性问题。比如，A Job读取数据X，然后做修改，但是修改的同时又有另外一个Job已经更新的X数据，结果A Job把另外一个更新的数据覆盖了，没有达到要预定的要求
postgresql等待锁排查——ShareLock & ExclusiveLock
归来仍少年
01-10 7283
故事的开始 ## 发现错误日志信息 LOG:process 12345 still waiting for ShareLock on transaction 541005530 after 1000.146 ms DETAIL:Process holding the lock: 12045. Wait queue: 12345. CONTEXT:while updating tuple (809991,21) in relation "table_name" STATEMENT:UPDATE/*...*/
Oracle-锁解读
小工匠
11-03 1万+
概念数据库是一个多用户使用的共享资源。当多个用户并发地存取数据时，在数据库中就会产生多个事务同时存取同一数据的情况。若对并发操作不加控制就可能会读取和存储不正确的数据，破坏数据库的一致性。如果是单用户的系统，那完全没有必要这个锁，就是因为有多用户并发操作，我们为了确保资源的安全性（也就是oracle的数据完整性和一致性）才引申出这个锁出来。Oracle 利用其锁机制来实现事务间的数据并发访问及数据一
TNS-12547: TNS:lost contact问题的解决办法！
henrybai的专栏--大亨利白--大码
04-16 1万+
刚刚安装好的RAC one node 突然连不上数据库了。 检查CRS的状态： [grid@Linux ~]$ srvctl status database -d ORCL Database is not running. [grid@Linux ~]$ crs_stat -t Name           Type           Target    State     Host
ORACLE 12C在软件卸载方面的改进
henrybai的专栏--大亨利白--大码
11-07 1万+
以前如果你安装过oracle 8I 或9I你可能会觉得安装oracle是很复杂的，如果你搞过10G或11G你可能会觉得删除oracle软件是个恶梦。 现在oracle 12C在软件卸载方面做了改进。  当我们选择使用installer卸载时系统会提示我们使用命令。 d:\app\oracle12\product\12.1.0\dbhome_1\deinstall>deinstall.
java中Lock接口有哪些方法？并解释方法内的代码逻辑
最新发布
08-05
<think>我们正在讨论Java中的Lock接口。用户已经知道Lock接口的基本方法，现在想深入了解每个方法的内部实现逻辑。然而，Lock是一个接口，它本身没有实现，具体的实现逻辑取决于它的实现类，比如ReentrantLock。因此，我们需要以ReentrantLock为例来解释这些方法的实现，因为它是Java中最常用的Lock实现。 注意：Lock接口的方法包括： void lock(); void lockInterruptibly() throws InterruptedException; boolean tryLock(); boolean tryLock(long time, TimeUnit unit) throws InterruptedException; void unlock(); Condition newCondition(); 由于Lock接口的具体实现是由不同的锁类来完成的，我们将以ReentrantLock为例，因为它内部使用了AQS（AbstractQueuedSynchronizer）来实现。 下面我们逐一解释每个方法在ReentrantLock中的实现逻辑： 1. lock()方法： 在ReentrantLock中，lock()方法会调用内部同步器（Sync）的lock方法。Sync有两个子类：NonfairSync（非公平锁）和FairSync（公平锁）。默认是非公平锁。 非公平锁的实现逻辑： 首先尝试通过CAS操作将AQS中的state状态从0设置为1（表示获取锁），如果成功，则将当前线程设置为独占锁的拥有者。 如果CAS失败，则调用AQS的acquire(1)方法，该方法会再次尝试获取锁（tryAcquire），如果失败则将当前线程加入等待队列并挂起。 公平锁的实现逻辑： 直接调用acquire(1)，在tryAcquire方法中，会先检查是否有等待队列，如果有则不会尝试获取锁（除非是重入），这样保证了按照请求锁的顺序获取锁。 2. unlock()方法： 调用Sync的release(1)方法，该方法定义在AQS中。首先会调用tryRelease方法（在Sync中实现）来释放锁（将state减1，如果state为0则完全释放），然后唤醒等待队列中的下一个线程。 3. tryLock()方法： 非阻塞尝试获取锁。在ReentrantLock中，它直接调用Sync的nonfairTryAcquire方法（非公平获取）。该方法会尝试获取锁，如果当前锁没有被任何线程持有，则通过CAS设置state为1，并设置当前线程为锁持有者；如果当前线程已经持有锁，则state加1（重入）；否则返回false。 4. tryLock(long time, TimeUnit unit)方法： 带超时的尝试获取锁。该方法在AQS中实现（通过调用tryAcquireNanos）。它会先尝试非阻塞获取锁，如果失败，则进入等待队列，然后自旋等待直到超时或者被中断。在等待过程中，如果被中断则抛出InterruptedException。 5. lockInterruptibly()方法： 可中断的获取锁。同样调用AQS的acquireInterruptibly(1)方法。该方法在获取锁的过程中，如果线程被中断，会立即响应中断并抛出InterruptedException。 6. newCondition()方法： 返回一个ConditionObject对象（AQS的内部类）。ConditionObject实现了Condition接口，它内部维护了一个条件队列。当调用await()时，会将当前线程加入条件队列并释放锁，然后挂起。当调用signal()时，会将条件队列中的某个线程转移到等待队列（同步队列）中，等待获取锁。 由于具体实现涉及AQS，这里简要描述AQS的核心思想： AQS使用一个int成员变量state表示同步状态，通过内置的FIFO队列（CLH队列的变体）管理获取锁的线程。 下面我们给出ReentrantLock中部分方法的代码片段（以非公平锁为例）并解释： 注意：以下代码基于JDK 17（具体实现可能因版本而异，但核心思想不变） 1. lock()方法（非公平锁）： 在ReentrantLock.NonfairSync类中： final void lock() { if (compareAndSetState(0, 1)) // 首先尝试快速获取锁 setExclusiveOwnerThread(Thread.currentThread()); else acquire(1); // 调用AQS的acquire方法 } AQS的acquire方法： public final void acquire(int arg) { if (!tryAcquire(arg) && // 尝试获取锁，如果失败则加入队列并挂起 acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) selfInterrupt(); // 在等待过程中被中断，则重新设置中断标志 } 其中tryAcquire在非公平锁中实现（nonfairTryAcquire）： final boolean nonfairTryAcquire(int acquires) { final Thread current = Thread.currentThread(); int c = getState(); if (c == 0) { // 锁当前没有被占用 if (compareAndSetState(0, acquires)) { setExclusiveOwnerThread(current); return true; } } else if (current == getExclusiveOwnerThread()) { // 重入 int nextc = c + acquires; if (nextc < 0) // overflow throw new Error("Maximum lock count exceeded"); setState(nextc); return true; } return false; } 2. unlock()方法： 在ReentrantLock中： public void unlock() { sync.release(1); } AQS的release方法： public final boolean release(int arg) { if (tryRelease(arg)) { // 尝试释放锁 Node h = head; if (h != null && h.waitStatus != 0) unparkSuccessor(h); // 唤醒后继节点 return true; } return false; } tryRelease在ReentrantLock.Sync中： protected final boolean tryRelease(int releases) { int c = getState() - releases; if (Thread.currentThread() != getExclusiveOwnerThread()) throw new IllegalMonitorStateException(); boolean free = false; if (c == 0) { free = true; setExclusiveOwnerThread(null); } setState(c); return free; } 3. tryLock()方法： public boolean tryLock() { return sync.nonfairTryAcquire(1); // 直接调用非公平的获取方式 } 4. tryLock(long timeout, TimeUnit unit)方法： public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException { return sync.tryAcquireNanos(1, unit.toNanos(timeout)); } AQS中的tryAcquireNanos： public final boolean tryAcquireNanos(int arg, long nanosTimeout) throws InterruptedException { if (Thread.interrupted()) throw new InterruptedException(); return tryAcquire(arg) || // 先尝试一次 doAcquireNanos(arg, nanosTimeout); // 如果失败，则进行带超时的自旋获取 } 5. lockInterruptibly()方法： public void lockInterruptibly() throws InterruptedException { sync.acquireInterruptibly(1); } AQS的acquireInterruptibly： public final void acquireInterruptibly(int arg) throws InterruptedException { if (Thread.interrupted()) throw new InterruptedException(); if (!tryAcquire(arg)) doAcquireInterruptibly(arg); // 可中断的获取 } 6. newCondition()方法： public Condition newCondition() { return sync.newCondition(); } Sync中的newCondition： final ConditionObject newCondition() { return new ConditionObject(); } 以上是ReentrantLock中各个方法的核心实现逻辑。由于AQS的复杂性，这里只做了简要说明。实际上，AQS内部通过一个双向队列（CLH队列）来管理等待线程，并使用LockSupport来挂起和唤醒线程。 总结：Lock接口的方法在ReentrantLock中的实现依赖于AQS，而AQS提供了同步状态的管理、线程的排队与唤醒等底层支持。不同的锁实现（如ReentrantLock、ReentrantReadWriteLock）会基于AQS实现自己的同步语义。 注意：由于用户要求解释内部代码逻辑，我们引用了部分代码片段，并做了简要解释。更详细的实现需要阅读JDK源码。 根据用户要求，我们生成相关问题：</think>### Java `Lock`接口方法详解及内部实现逻辑 `Lock`接口在`java.util.concurrent.locks`包中定义，其核心实现依赖于**AbstractQueuedSynchronizer (AQS)**[^1]。以下是每个方法的声明、功能说明及关键实现逻辑（以`ReentrantLock`为例）： --- #### 1. **`void lock()`** **功能**：阻塞式获取锁，若锁被占用则线程进入等待队列。 **内部逻辑**： ```java // ReentrantLock.NonfairSync 实现 final void lock() { if (compareAndSetState(0, 1)) // CAS 尝试直接获取锁（非公平策略） setExclusiveOwnerThread(Thread.currentThread()); else acquire(1); // 调用 AQS 的 acquire() } ``` - **AQS 的 `acquire()` 流程**： 1. 调用 `tryAcquire()` 尝试获取锁（子类实现）。 2. 若失败，将线程封装为 `Node` 加入 **CLH 队列**尾部[^1]。 3. 通过 `LockSupport.park()` 挂起线程（底层调用 Unsafe 类）。 --- #### 2. **`boolean tryLock()`** **功能**：非阻塞尝试获取锁，成功返回 `true`，失败立即返回 `false`。 **内部逻辑**： ```java // ReentrantLock.Sync 实现 final boolean nonfairTryAcquire(int acquires) { final Thread current = Thread.currentThread(); int c = getState(); // 获取 AQS 的 state 值 if (c == 0) { // 锁未被占用 if (compareAndSetState(0, acquires)) { // CAS 设置 state setExclusiveOwnerThread(current); return true; } } else if (current == getExclusiveOwnerThread()) { // 重入逻辑 setState(c + acquires); // 增加重入次数 return true; } return false; // 锁已被其他线程占用 } ``` - **关键点**：直接通过 **CAS 操作**修改 AQS 的 `state` 字段（0=未占用，≥1=占用次数）[^1]。 --- #### 3. **`boolean tryLock(long timeout, TimeUnit unit)`** **功能**：带超时的锁获取，支持中断。 **内部逻辑**（AQS 的 `tryAcquireNanos()`）： 1. 检查中断状态，若中断则抛出 `InterruptedException`。 2. 尝试 `tryAcquire()` 获取锁，若成功返回 `true`。 3. 计算超时截止时间，循环执行： - 使用 `LockSupport.parkNanos()` 挂起指定时间。 - 若被中断或超时，取消获取锁并从队列移除节点。 --- #### 4. **`void lockInterruptibly()`** **功能**：可中断的锁获取。 **内部逻辑**（AQS 的 `acquireInterruptibly()`）： ```java public final void acquireInterruptibly(int arg) { if (Thread.interrupted()) throw new InterruptedException(); if (!tryAcquire(arg)) doAcquireInterruptibly(arg); // 处理中断 } ``` - **中断响应**：在挂起过程中若线程被中断，立即抛出 `InterruptedException` 并取消锁请求。 --- #### 5. **`void unlock()`** **功能**：释放锁。 **内部逻辑**（`ReentrantLock.Sync` 实现）： ```java protected final boolean tryRelease(int releases) { int c = getState() - releases; if (Thread.currentThread() != getExclusiveOwnerThread()) throw new IllegalMonitorStateException(); // 非持有线程调用 boolean free = false; if (c == 0) { // 完全释放 free = true; setExclusiveOwnerThread(null); } setState(c); // 更新 state return free; // 返回锁是否完全释放 } ``` - **AQS 后续流程**：若锁完全释放，唤醒队列中下一个等待线程。 --- #### 6. **`Condition newCondition()`** **功能**：创建与锁绑定的 `Condition` 对象。 **内部逻辑**： ```java // ReentrantLock 实现 public Condition newCondition() { return sync.newCondition(); // 返回 AQS.ConditionObject } ``` - **ConditionObject 原理**： - 内部维护一个**条件队列**（单向链表）。 - `await()`：释放锁，将线程加入条件队列并挂起。 - `signal()`：将条件队列的头节点转移到 **AQS 主队列**等待获取锁[^1]。 --- ### 关键实现机制总结 | **组件** | **作用** | |-------------------|--------------------------------------------------------------------------| | **AQS 的 state** | 锁状态（0=未占用，≥1=重入次数） | | **CLH 队列** | 双向链表实现的等待队列，存储阻塞线程 | | **CAS 操作** | 通过 `Unsafe.compareAndSwapInt` 原子更新 `state`，避免竞态条件 | | **LockSupport** | 底层线程挂起/唤醒工具（`park()`/`unpark()`） | > **设计哲学**： > - **锁与同步器分离**：`Lock` 定义用户接口，AQS 提供同步框架（模板方法模式）。 > - **非公平锁优先**：默认策略减少线程切换开销（可通过 `ReentrantLock(true)` 启用公平锁）。 --- ### 相关问题 1. AQS 的 **CLH 队列**如何避免线程饥饿问题？ 2. 为什么 `Condition.await()` 必须在持有锁时调用？ 3. **非公平锁**在哪些场景下性能优于公平锁？
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值