JAVA中锁概及运用
锁
（4） 如果两个线程要执行一个类中的synchronized方法，并且两个线程使用相同的实例来调用方法，那么一次只能有一个线程能够执行方法，里一 个需要等待，知道锁被释放
（5） 如果线程拥有同步和非同步方法，则非同步方法可以被多个线程自由访问而不受锁的限制
线程死锁：
死锁对于Java程序来说是很复杂的，也很难发现问题，当两个线程被阻塞，每个线程在等待另一个线程时就发生死锁。死锁是线程间相互等待锁锁造成 的，在实际中发生的概率非常的小。真让你写个死锁程序，不一定好使，但是，一旦程序发生死锁，程序将死掉。
阻塞时要注意哪个对象背用于锁定：
1调用同一个对象中非静态同步方法的线程将彼此阻塞。如果是不同对象，则每个线程有自己的对象的锁，线程间彼此互不干预。
2调用同一个类中的静态同步方法的线程将彼此阻塞，它们都是锁定在相同的Class 对象上。
3 静态同步方法和非静态同步方法将永远不会彼此阻塞，因为静态方法锁定在Class 对象上，非静态方法锁定在该类的对象上。
4 对于同步代码块，要看清楚什么对象已经用于锁定（synchronized后面括号的内容）。在同一个对象上进行同步的线程将彼此阻塞，在不同对象上锁 定的线程将永 远不会彼此阻塞。
静态方法同步
要同步静态方法，需要一个用整个类对象的锁，这个对象就是这个类（***.Class） 线程不能获得锁会 Nhomakorabea么样：
如果线程师徒进入同步方法，而其锁已经被占用，则线程在该对象上被阻塞
（6） 线程睡眠时，他所持的任何锁都不会释放
（7） 线程可以获得多个锁，如果一个对象的同步方法里调用另外一个对象同步方法，则获得了两个对象的同步锁
（8） 在使用同步代码块时，应该指定在哪个对象上同步，也就是说要获取哪个对象的锁
分段锁 java实现
分段锁 java实现【原创实用版】目录1.分段锁的概述2.Java 中实现分段锁的方法3.分段锁的优点与不足4.实例：使用 ReentrantLock 实现分段锁正文一、分段锁的概述分段锁，又称为粒度锁，是一种在多线程并发访问共享资源时，通过将锁分成多个段落，每个段落只允许一个线程访问的锁机制。
分段锁相较于其他锁机制，如互斥锁、读写锁等，能够在保证线程安全的同时，减少锁的竞争，提高程序的并发性能。
二、Java 中实现分段锁的方法在 Java 中，可以使用 ReentrantLock 类来实现分段锁。
ReentrantLock 提供了一种灵活的锁机制，可以根据需要设置锁的粒度。
下面是一个使用 ReentrantLock 实现分段锁的示例：```javaimport java.util.concurrent.locks.ReentrantLock;public class SegmentedLockExample {private final ReentrantLock lock = new ReentrantLock(10); // 设置锁的粒度为 10public void someMethod() {lock.lock(); // 获取锁try {// 临界区代码} finally {lock.unlock(); // 释放锁}}}```三、分段锁的优点与不足1.优点：- 降低锁竞争。
分段锁将锁分成多个段落，每个段落只允许一个线程访问，从而降低了锁的竞争，提高了程序的并发性能。
- 粒度可调。
可以根据实际需求设置锁的粒度，灵活地控制并发访问的策略。
2.不足：- 相较于互斥锁等其他锁机制，分段锁的实现较为复杂。
- 分段锁的粒度过大或过小都可能导致性能问题。
粒度太小可能导致锁竞争加剧，粒度太大可能导致并发性能下降。
四、实例：使用 ReentrantLock 实现分段锁在上述示例中，我们使用 ReentrantLock 类设置了锁的粒度为 10，即最多允许 10 个线程并发访问。
redissonclient.getlock_原理_概述及解释说明
redissonclient.getlock 原理概述及解释说明1. 引言1.1 概述本文将重点介绍redissonclient.getlock方法的原理和应用场景。
Redisson是一个开源的Java客户端，用于操作Redis数据库。
在分布式系统中，确保数据的一致性和并发控制是非常重要的。
分布式锁作为一种常见的解决方案，可以确保在多个线程或进程之间对共享资源进行互斥访问。
1.2 文章结构本文主要包括以下几个部分：引言、redissonclient.getlock原理概述、redissonclient.getlock方法的实现原理、使用示例和注意事项以及结论与总结。
1.3 目的本文旨在深入了解redissonclient.getlock方法的工作原理，帮助读者更好地理解和使用该方法。
同时，通过使用示例和注意事项的介绍，帮助读者避免在实际应用中可能遇到的问题，并提供最佳实践建议。
以上就是“1. 引言”部分内容，请根据需要进行修改补充。
2. redissonclient.getlock 原理概述：2.1 Redisson 客户端简介：Redisson是一个开源的Java客户端，用于操作Redis数据库。
它提供了一系列的分布式对象和服务，其中包括分布式锁。
Redisson客户端可以通过直接访问原生的Redis命令，或者通过高级面向对象的API来进行操作。
2.2 Redis 分布式锁概述：分布式锁是在分布式系统中保护共享资源的一种机制。
在多个节点同时访问共享资源时，使用分布式锁可以确保只有一个节点能够获得对该资源的独占访问权限。
这样可以有效地避免数据竞争和并发冲突问题。
2.3 redissonclient.getlock 方法的作用：redissonclient.getlock方法是Redisson提供的获取分布式锁的方法之一。
该方法返回一个可重入锁（Reentrant Lock）对象，并且支持公平锁和非公平锁两种模式。
java 锁的底层原理
java 锁的底层原理Java中的锁是一个非常重要的概念，它在多线程编程中扮演着关键的角色。
Java中的锁机制，包括synchronized关键字、ReentrantLock类等，都是为了实现线程安全而存在的。
那么，Java 锁的底层原理是什么呢？Java中的锁，其实是通过底层的对象监视器(monitor)实现的。
每个Java对象都有一个关联的对象监视器，它可以用来控制对该对象的并发访问。
当一个线程需要访问一个被锁住的对象时，它需要先获得该对象的对象监视器，然后进入同步块中执行相应的代码。
当线程执行完同步块中的代码，并释放了该对象的对象监视器时，其他线程才能够获得该对象的对象监视器进入同步块执行相应的代码。
在底层实现上，Java中的锁是通过对象头中的标记位实现的。
当一个对象被锁定时，其对象头中的标记位会被设置为1，表示该对象被锁定。
当一个线程想要获得该对象的锁时，它会先检查该对象头中的标记位是否为1，如果为1，则表示该对象被其他线程锁定，当前线程需要进入等待状态；如果为0，则表示该对象未被锁定，当前线程可以获得该对象的锁并进入同步块执行相应的代码。
在Java中，synchronized关键字是最基本的锁机制。
它可以用来实现对象的同步访问和线程的互斥访问。
在底层实现上，synchronized关键字是通过monitorenter和monitorexit指令实现的。
monitorenter指令用于获得对象的对象监视器，而monitorexit 指令用于释放对象的对象监视器。
另外，Java中还有一种更灵活的锁机制，就是ReentrantLock 类。
它可以通过lock和unlock方法实现对锁的控制，同时还提供了更多高级的功能，如可重入锁、公平锁、锁中断等。
总之，Java锁的底层原理是通过对象监视器实现的，其具体实现方式包括对象头中的标记位和monitorenter、monitorexit指令。
在实际编程中，我们可以根据不同的需求选择不同的锁机制来实现线程安全。
分段锁 java实现
分段锁java实现摘要：一、分段锁简介1.分段锁的定义2.分段锁的作用3.分段锁与乐观锁、悲观锁的区别二、Java分段锁实现1.ReentrantReadWriteLock2.ReadWriteLock接口3.StampedLock三、分段锁的应用场景1.提高并发性能2.避免死锁3.实现并发控制四、分段锁的优缺点1.优点a.灵活性b.高效性c.可扩展性2.缺点a.实现复杂b.内存占用较多正文：一、分段锁简介分段锁，又称为可重入锁、读写锁，是一种允许多个线程同时对共享资源进行读取操作，但只允许一个线程进行写入操作的锁。
分段锁的主要目的是在保证数据一致性的前提下，提高程序的并发性能。
它通过将共享资源的读写操作分开，降低了锁的竞争程度，从而提高了程序的运行效率。
在Java中，分段锁主要由以下几种实现：ReentrantReadWriteLock、ReadWriteLock接口和StampedLock。
二、Java分段锁实现1.ReentrantReadWriteLockReentrantReadWriteLock是Java并发编程中常用的一种分段锁实现。
它允许多个线程同时进行读取操作，但同一时刻只允许一个线程进行写入操作。
ReentrantReadWriteLock提供了两个方法：withReadLock()和withWriteLock()，分别用于获取读锁和写锁。
2.ReadWriteLock接口ReadWriteLock接口是Java提供的另一个分段锁实现。
它包含两个方法：readLock()和writeLock()，分别用于获取读锁和写锁。
与ReentrantReadWriteLock相比，ReadWriteLock接口的实现更加灵活，可以自定义锁的策略。
3.StampedLockStampedLock是Java 8引入的一种新的分段锁实现。
它通过引入“标签”的概念，允许多个线程同时持有读锁，但在写入操作时需要等待其他线程释放读锁。
可重入锁原理
可重入锁原理可重入锁是一种具有线程可重入性的锁，这种锁可以被同一个线程多次获取。
在深入理解可重入锁之前，我们需要先了解锁的概念。
锁是一种同步机制，它用于保护共享资源不被并发访问和修改。
当一个线程获取了某个锁时，其他线程需要等待该线程释放锁之后才能获取该锁。
一个线程获取了某个锁之后，只能由该线程来释放该锁，这是由系统自动实现的。
因此，一个线程只有在保持该锁的拥有权时，才有权访问共享资源。
可重入锁不同于普通锁，它允许同一个线程多次获取同一个锁。
这样做的好处在于：如果一个线程正在持有某个锁而又需要获取同一个锁，那么它不需要等待自己释放锁后再次获取锁。
因为该锁是可重入的，所以该线程可以直接再次获取锁，从而避免了死锁问题的发生。
在Java中，ReentrantLock就是一种可重入锁，它实现了可重入性的机制。
可重入锁的原理主要包括以下几个方面：1. 原子性可重入锁的实现需要保证锁的获取和释放操作具有原子性。
在Java中，我们可以使用synchronized语句块或ReentrantLock锁来实现锁的原子性。
锁的原子性可以保证同一个线程获取同一个锁时，可以正确地计数，并重复获取该锁。
2. 计数器当一个线程获取了一个可重入锁时，计数器会被加1。
每当该线程重新获取该锁时，计数器会再次加1。
当计数器等于0时，该线程释放该锁。
可重入锁中的计数器是对当前线程持有该锁的次数的统计，因此称为重入次数。
3. 释放锁当一个线程释放一个可重入锁时，计数器会相应地减1。
只有当计数器减到0时，该锁才被真正地释放。
如果当前线程持有该锁的次数大于1，那么该线程需要多次释放锁，直到计数器减为0为止。
这种实现方式可以确保同一个线程可以重复获取同一个锁，并且可以让该线程持有锁的时间更长。
4. 线程安全可重入锁需要保证线程安全性。
当多个线程同时访问同一个锁时，必须保证只有一个线程可以获取该锁，其他线程需要等待。
对于Java中的ReentrantLock锁而言，它可以设置公平或非公平锁，从而保证锁的获取顺序是公平的或不公平的。
java synchronized的用法
在Java编程语言中，synchronized关键字是用于实现多线程同步的重要工具。
通过在代码块或方法前添加synchronized关键字，可以确保同一时刻只有一个线程可以进入该代码块或方法，从而避免多线程并发访问时可能出现的数据不一致或异常情况。
在本文中，我将从简到繁地探讨Java synchronized的用法，以帮助您更全面地理解这一重要的概念。
1. 普通锁方法在最简单的情况下，可以使用synchronized关键字来锁定整个方法，以确保同一时刻只有一个线程可以进入该方法。
例如：```javapublic synchronized void doSomething() {// 线程安全操作}```在这个例子中，方法doSomething()被标记为synchronized，因此在同一时刻只有一个线程可以调用该方法，从而避免了多线程并发访问时可能出现的问题。
2. 对象锁和类锁除了锁定整个方法外，还可以使用synchronized关键字来锁定对象或类。
在Java中，每个对象都有一个内置的锁，也称为对象监视器。
通过使用对象的锁，可以确保在同一时刻只有一个线程可以访问该对象的同步代码块。
例如：```javapublic void doSomething() {synchronized(this) {// 线程安全操作}}public static synchronized void doAnotherThing() {// 线程安全操作}```在这个例子中，第一个方法使用了对象锁，即通过synchronized(this)来锁定当前对象；第二个方法则使用了类锁，即通过在静态方法前添加synchronized关键字来锁定整个类。
这样可以确保在同一时刻只有一个线程可以访问相应的代码块，从而实现线程安全。
3. 临界区和锁对象在多线程编程中，临界区是指一段需要互斥访问的代码区域。
为了确保临界区的线程安全，可以使用锁对象来进行同步控制。
静态方法加锁，和非静态方法加锁区别
静态⽅法加锁，和⾮静态⽅法加锁区别博客分类：今天看了到有意思的题：在静态⽅法上加锁和⾮静态⽅法加锁有什么区别，从⽽再次引出锁机制的⼀些理解。
先看⽅法：// 这是⼀个很简单的类，⾥⾯共享静态变量 num,然后⼀个静态和⾮静态⽅法，都加上锁// 我们假设有两个线程同时操作这两个⽅法，那么数据能互斥吗？Java代码1. public class Walk {2. public static int num = 100;3. public static Walk walk = new Walk();4. // 静态5. public synchronized static int run(){6. int i = 0;7. while (i < 10) {8. try {9. num --;10. i++;11. System.out.println(Thread.currentThread().getName()+":"+num);12. Thread.sleep(1000);13. } catch (InterruptedException e) {14. e.printStackTrace();15. }16. }17. return num ;18. }19. // ⾮静态20. public synchronized int walk(){21. int i = 0;22. while (i < 10) {23. try {24. num --;25. i++;26. System.out.println(Thread.currentThread().getName()+":"+num);27. Thread.sleep(1000);28. } catch (InterruptedException e) {29. e.printStackTrace();30. }31. }32. return num ;33. }34. }35.36. // 先建⽴两个测试类，这⾥我们默认循环10次37. public class T3 implements Runnable {38. @Override39. public void run() {40. Walk walk = new Walk();41. //Walk walk = Walk.walk;42. walk.walk();43. }44. }45.46. public class T1 implements Runnable{47. @Override48. public void run() {49. Walk walk = new Walk();50. //Walk walk = Walk.walk;51. // 这⾥我依然⽤的new52. walk.run();53. }54. }Java代码1. // 测试⽅法2. public class Test {3. public static void main(String[] args) {4. Thread t1 = new Thread(new T1());5. Thread t3 = new Thread(new T3());6. ExecutorService es = Executors.newCachedThreadPool();7. es.execute(t1);8. es.execute(t3);9. es.shutdown();10. }11. }// 测试数据我就不完全列出了pool-1-thread-1:98pool-1-thread-2:98pool-1-thread-2:97pool-1-thread-1:96.....可以看出两个线程没有互斥，这是为什么呢？OK，我们将static 关键字去掉，代码我就不贴了，直接看结果。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
一、锁的概念及分类ORACLE数据库是现今数据库领域应用最广泛的，同时它也是一个庞大的系统，全面了解它、玩转它不但需要一定的理论知识，更需要开发经验与工程经验。
本人是ORACLE一爱好者，以下是本人对ORACLE锁的一些经验，希望能与大家共同分享。
ORACLE锁具体分为以下几类：1.按用户与系统划分，可以分为自动锁与显示锁自动锁：当进行一项数据库操作时，缺省情况下，系统自动为此数据库操作获得所有有必要的锁。
显示锁：某些情况下，需要用户显示的锁定数据库操作要用到的数据，才能使数据库操作执行得更好，显示锁是用户为数据库对象设定的。
2.按锁级别划分，可分为共享锁、共享更新锁、排它锁共享锁：共享锁使一个事务对特定数据库资源进行共享访问——另一事务也可对此资源进行访问或获得相同共享锁。
共享锁为事务提供高并发性，但如拙劣的事务设计+共享锁容易造成死锁或数据更新丢失。
―锁定表―仅允许其他用户执行查询操作―不能插入、更新和删除―多个用户可以同时在同一表中放置此锁―lock tab le table_name―in share mode [nowait];― rollback 和commit 命令释放锁― nowait 关键字告诉其他用户不用等共享更新锁―锁定要被更新的行―允许其他用户同时查询、插入、更新未被锁定的行―在 SELECT 语句中使用“FOR UPDATE”子句，可以强制使用共享更新锁―允许多个用户同时锁定表的不同行加锁的两种方法1 lock table tab_name in share update mode;2 select column1,column2from goodswhere goodswhere gid=1001for update of column1,column2排它锁：事务设置排它锁后，该事务单独获得此资源，另一事务不能在此事务提交之前获得相同对象的共享锁或排它锁。
―与其他两种锁相比，排他锁是限制性最强的表锁―仅允许其他用户查询数据―不允许执行插入、删除和更新操作―在同一时间仅允许一位用户在表上放置排他锁―共享锁与此相反lock table tab_name in exclusive mode;lock table<表名>[<表名>]...in share mode [nowait]lock table< 表名>[<表名>]...in exclusive mode [nowait]lock table<表名>[<表名>]...in share update mode[nowait]3.按操作划分，可分为DML锁、DDL锁+DML锁又可以分为，行锁、表锁、死锁-行锁：当事务执行数据库插入、更新、删除操作时，该事务自动获得操作表中操作行的排它锁。
手动锁定方式:SELECT…FOR UPDATE 子句―在表的一行或多行上放置排他锁―用于防止其他用户更新该行―可以执行除更新之外的其他操作―select * from goods where gid=1001―for update of gname;―只有该用户提交事务，其他用户才能够更新gnameFOR UPDATE WAIT 子句―Oracle9i 中的新增功能―防止无限期地等待锁定的行―等待间隔必须指定为数值文字―等待间隔不能是表达式、赋值变量或 PL/SQL变量―select * from goods wheregid=1001 for update of gname wait 3―等待用户释放更新锁的时间为3秒，否则超时。
-表级锁：当事务获得行锁后，此事务也将自动获得该行的表锁(共享锁),以防止其它事务进行DDL语句影响记录行的更新。
事务也可以在进行过程中获得共享锁或排它锁，只有当事务显示使用LOCK TABLE语句显示的定义一个排它锁时，事务才会获得表上的排它锁,也可使用LOCK TABLE显示的定义一个表级的共享锁(LOCK TABLE具体用法请参考相关文档)。
―可以设置为三种模式：共享、共享更新和排他语法：lock table<table_name>in<mode>;-死锁：当两个事务需要一组有冲突的锁，而不能将事务继续下去的话，就出现死锁。
如事务1在表A行记录#3中有一排它锁，并等待事务2在表A 中记录#4中排它锁的释放，而事务2在表A记录行#4中有一排它锁，并等待事务; 1在表A中记录#3中排它锁的释放，事务1与事务2彼此等待，因此就造成了死锁。
死锁一般是因拙劣的事务设计而产生。
死锁只能使用SQL下:alter system kill session "sid,serial#"；或者使用相关操作系统kill进程的命令，如UNIX下kill -9 sid,或者使用其它工具杀掉死锁进程。
+DDL锁又可以分为：排它DDL锁、共享DDL锁、分析锁-排它DDL锁：创建、修改、删除一个数据库对象的DDL语句获得操作对象的排它锁。
如使用alter table语句时，为了维护数据的完成性、一致性、合法性，该事务获得一排它DDL锁。
-共享DDL锁：需在数据库对象之间建立相互依赖关系的DDL语句通常需共享获得DDL锁。
如创建一个包，该包中的过程与函数引用了不同的数据库表，当编译此包时，该事务就获得了引用表的共享DDL锁。
-分析锁：ORACLE使用共享池存储分析与优化过的SQL语句及PL/SQL 程序，使运行相同语句的应用速度更快。
一个在共享池中缓存的对象获得它所引用数据库对象的分析锁。
分析锁是一种独特的DDL锁类型，ORACLE使用它追踪共享池对象及它所引用数据库对象之间的依赖关系。
当一个事务修改或删除了共享池持有分析锁的数据库对象时，ORACLE使共享池中的对象作废，下次在引用这条SQL/PLSQL语句时，ORACLE重新分析编译此语句。
4.内部闩锁内部闩锁：这是ORACLE中的一种特殊锁，用于顺序访问内部系统结构。
当事务需向缓冲区写入信息时，为了使用此块内存区域，ORACLE首先必须取得这块内存区域的闩锁，才能向此块内存写入信息。
Oracle锁表行级锁表级锁行级锁---- 行被排他锁定----在某行的锁被释放之前，其他用户不能修改此行----使用 commit 或 rollback 命令释放锁----Oracle 通过使用 INSERT、UPDATE 和SELECT…FOR UPDATE 语句自动获取行级锁SELECT…FOR UPDATE 子句―在表的一行或多行上放置排他锁―用于防止其他用户更新该行―可以执行除更新之外的其他操作―select * from go ods where gid=1001―for update of gname;―只有该用户提交事务，其他用户才能够更新gnameFOR UPDATE WAIT 子句―Oracle9i 中的新增功能―防止无限期地等待锁定的行―等待间隔必须指定为数值文字―等待间隔不能是表达式、赋值变量或 PL/SQL变量―select * from goods where gid=1001 for update of gnamewait 3―等待用户释放更新锁的时间为3秒，否则超时。
•表级锁―保护表的数据―在多个用户同时访问数据时确保数据的完整性―可以设置为三种模式：共享、共享更新和排他语法：lock table<table_name>in<mode>;共享锁―锁定表―仅允许其他用户执行查询操作―不能插入、更新和删除―多个用户可以同时在同一表中放置此锁―lock table table_name―in share mode [nowait];― rollback 和commit 命令释放锁― nowait 关键字告诉其他用户不用等待共享更新锁―锁定要被更新的行―允许其他用户同时查询、插入、更新未被锁定的行―在 SELECT 语句中使用“FOR UPDATE”子句，可以强制使用共享更新锁―允许多个用户同时锁定表的不同行加锁的两种方法lock table tab_name in share update mode;select column1,column2from goodswhere goodswhere gid=1001for update of column1,column2排他锁―与其他两种锁相比，排他锁是限制性最强的表锁―仅允许其他用户查询数据―不允许执行插入、删除和更新操作―在同一时间仅允许一位用户在表上放置排他锁―共享锁与此相反lock table tab_name in exclusive mode;lock table<表名>[<表名>]...in share mode [nowait]lock table< 表名>[<表名>]...in exclusive mode [nowait]lock table<表名>[<表名>]...in share update mode[nowait]二、oracle中如何区分行级锁，表级锁、死锁以及如何处理。
在ORACLE中，为了保证数据的一致性，在对数据库中的数据进行操作时，系统会进行对数据相应的锁定。
当程序对所做的修改进行提交(commit)或回滚后(rollback)后，锁住的资源便会得到释放，从而允许其它用户进行操作。
但是，有时，由于程序中的原因，锁住资源后长时间未对其工作进行提交；或是由于用户的原因，如调出需要修改的数据后，未及时修改并提交，而是放置于一旁；或是由于客户服务器方式中客户端出现"死机"，而服务器端却并未检测到，从而造成锁定的资源未被及时释放，影响到其它用户的操作。
这时，我们需要迅速地诊断出锁住资源的用户并解决其锁定。
1. 诊断系统中的锁为了找出系统中那些用户锁住资源以及那些用户在等待相应的资源，可使用以下语句(其中的/*+ NO_MERGE(..) */千万不可省略, 否则会很慢)：-- looklock.sql-- use the NO_MERGE hints can speed up the queryselect /*+ NO_MERGE(a) NO_MERGE(b) NO_MERGE(c) */ 'Wait' "Status", ername, a.machine, a.sid, a.serial#, st_call_et "Seconds", b.id1, c.sql_text "SQL"from v$session a, v$lock b, v$sqltext cwhere ername is not nulland a.lockwait = b.kaddrand c.hash_value =a.sql_hash_valueunionselect /*+ NO_MERGE(a) NO_MERGE(b) NO_MERGE(c) */ 'Lock' "Status", ername, a.machine, a.sid, a.serial#, st_call_et "Seconds", b.id1, c.sql_text "SQL"from v$session a, v$lock b, v$sqltext cwhere b.id1 in(select /*+ NO_MERGE(d) NO_MERGE(e) */ distinct e.id1from v$session d, v$lock ewhere d.lockwait = e.kaddr)and ername is not nulland a.sid = b.sidand b.request=0and c.hash_value =a.sql_hash_value;执行后的结果如下所示：Stat USERNAME MACHINE SID SERIAL# Seconds ID1---- ------------------------------ ---------------- --------- --------- --------- ---------SQL----------------------------------------------------------------Lock CIQUSR CIQ\DULMACER 12 966 245 131089select * from c_trade_mode for updateWait CIQUSR CIQ\DULMACER 10 735 111 131089update c_trade_mode set x_name = 'zzz' where x_code='5'Wait CIQUSR CIQ\DULMACER 15 106 1094 131089select * from c_trade_mode for update其中：Status有两种状态，LOCK表明该进程锁住了某个资源，WAIT表示该进程正在等待某个资源。