Oracle的事务及锁
oracle数据库知识点总结
oracle数据库知识点总结一、概述Oracle是一种关系型数据库管理系统（RDBMS），它是由Oracle Corporation开发和维护的。
Oracle数据库具有高可用性、可扩展性、安全性和可靠性等优点，因此被广泛应用于企业级应用程序。
二、基础知识1. 数据库对象：表、视图、索引、序列等。
2. 数据类型：数值型、字符型、日期型等。
3. SQL语言：DDL（数据定义语言）、DML（数据操作语言）、DCL （数据控制语言）等。
4. 数据库事务和锁：ACID特性、并发控制、锁机制等。
三、高级特性1. 分区表：将大表分解为多个小表，提高查询效率。
2. 备份和恢复：使用RMAN进行备份和恢复，保证数据的完整性和可靠性。
3. 高可用性：使用Data Guard实现主备库切换，保证系统的连续性。
4. 性能优化：使用AWR报告进行系统调优，提高系统响应速度。
四、安全管理1. 用户管理：创建用户并分配权限，限制用户对数据库的访问权限。
2. 角色管理：创建角色并分配权限，方便对多个用户进行权限管理。
3. 数据加密：使用TDE对敏感数据进行加密，保证数据安全。
4. 审计管理：记录用户的操作行为，并进行审计分析，保证数据的安全性和完整性。
五、常见问题1. ORA错误：常见的ORA错误有ORA-00904、ORA-01017等。
2. 数据库性能问题：常见的数据库性能问题有慢查询、死锁等。
3. 数据库备份和恢复问题：常见的备份和恢复问题有备份失败、恢复失败等。
4. 安全管理问题：常见的安全管理问题有密码泄露、权限不当等。
六、总结Oracle数据库是企业级应用程序中最为流行的关系型数据库之一。
掌握Oracle数据库的基础知识和高级特性，以及安全管理和常见问题解决方法，对于保证系统稳定运行和数据安全具有重要意义。
oracle锁表问题处理
oracle锁表问题处理查询表的状况的对象：V$LOCK, V$LOCKED_OBJECT, V$SESSION, V$SQLAREA, V$PROCESS select * from v$locked_objectselect * from dba_objects方法：首先查看哪些表被锁住了select b.owner,b.object_name,a.session_id,a.locked_modefrom v$locked_object a,dba_objects bwhere b.object_id = a.object_id;select ername,b.sid,b.serial#,logon_timefrom v$locked_object a,v$session bwhere a.session_id = b.sid order by b.logon_time;杀进程中的会话alter system kill session 'sid,serial#';例如：alter system kill session '29,5497';查询锁表的方法：SELECT S.SID SESSION_ID, ERNAME, s.SERIAL#,DECODE(LMODE, 0, 'None', 1, 'Null', 2, 'Row-S (SS)', 3, 'Row-X (SX)', 4, 'Share', 5, 'S/Row-X (SSX)', 6, 'Exclusive',TO_CHAR(LMODE)) MODE_HELD, DECODE(REQUEST, 0, 'None', 1, 'Null', 2, 'Row-S (SS)', 3, 'Row-X (SX)', 4, 'Share', 5, 'S/Row-X (SSX)', 6, 'Exclusive',TO_CHAR(REQUEST)) MODE_REQUESTED, O.OWNER||'.'||O.OBJECT_NAME||' ('||O.OBJECT_TYPE||')',S.TYPE LOCK_TYPE, L.ID1 LOCK_ID1, L.ID2 LOCK_ID2FROM V$LOCK L, SYS.DBA_OBJECTS O, V$SESSION SWHERE L.SID = S.SID AND L.ID1 = O.OBJECT_ID ;解锁方法：ALTER SYSTEM KILL SESSION 'SID,SERIR#'0----------0--------SQL> alter system kill session '1679,2456';alter system kill session '1679,2456'*ERROR at line 1:ORA-01031: insufficient privilegesgrant execute on p_kill_user_session to rtgs_liush();操作的时候用命令：EXEC SYS.P_KILL_USER_SESSION(1679);------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------数据库锁表的分析与解决上面介绍了内存溢出的原因和处理方法，下面再介绍一下数据库锁表及阻塞的原因和处理办法。
oracle锁原理
Oracle锁原理详解1. 概述在Oracle数据库中，锁是用于控制并发访问的一种机制。
当多个用户同时访问数据库时，为了保证数据的一致性和完整性，Oracle会对数据进行加锁，以防止其他用户对数据的修改。
本文将详细介绍Oracle锁的基本原理。
2. 锁的类型Oracle中的锁可以分为两种类型：共享锁（Shared Lock）和排他锁（Exclusive Lock）。
•共享锁：多个事务可以同时获取共享锁，并且可以并发读取数据，但不能修改数据。
共享锁用于保证数据的一致性，即多个事务可以同时读取相同的数据，但不能同时修改数据。
•排他锁：只有一个事务可以获取排他锁，并且其他事务不能同时获取共享锁或排他锁。
排他锁用于保证数据的完整性，即一个事务在修改数据时，其他事务不能同时读取或修改数据。
3. 锁的级别Oracle中的锁可以分为多个级别，包括表级锁、行级锁和字段级锁。
•表级锁：锁定整个表，阻止其他事务对表的修改。
表级锁对于大型表来说，可能会导致性能问题，因为它会阻塞其他事务的访问。
•行级锁：锁定表中的一行数据，其他事务可以并发读取其他行的数据。
行级锁可以更细粒度地控制并发访问，但可能会导致死锁问题。
•字段级锁：锁定表中的一个或多个字段，其他事务可以并发读取或修改其他字段的数据。
字段级锁可以进一步细化锁的粒度，但也可能导致死锁问题。
4. 锁的控制Oracle中的锁由数据库管理系统（DBMS）自动控制，用户无需手动操作。
当一个事务对数据进行修改时，DBMS会自动为该数据加上相应的锁，并在事务提交或回滚后释放锁。
锁的控制是通过锁定机制和并发控制机制实现的。
•锁定机制：当一个事务对数据进行修改时，DBMS会自动为该数据加上相应的锁。
锁定机制可以保证在并发访问时，每个事务都能正确地读取和修改数据。
•并发控制机制：当多个事务同时访问数据库时，DBMS会根据事务的隔离级别来控制并发访问。
并发控制机制可以避免脏读、不可重复读和幻读等问题。
oracle数据库面试题目(3篇)
第1篇1. 请简述Oracle数据库的体系结构，并说明各层的作用。
2. 请解释什么是Oracle实例？实例与数据库之间的关系是什么？3. 请简述Oracle数据库的存储结构，包括数据文件、控制文件、日志文件等。
4. 请说明Oracle数据库的内存结构，包括SGA、PGA等。
5. 请解释Oracle数据库的备份策略，包括全备份、增量备份、差异备份等。
6. 请说明Oracle数据库的恢复策略，包括不完全恢复、完全恢复等。
7. 请解释Oracle数据库的事务管理，包括事务的ACID特性。
8. 请说明Oracle数据库的锁机制，包括共享锁、排他锁等。
9. 请解释Oracle数据库的并发控制，包括多版本并发控制（MVCC）。
10. 请说明Oracle数据库的安全机制，包括角色、权限、用户等。
二、SQL语言1. 请简述SQL语言的组成，包括数据定义语言（DDL）、数据操纵语言（DML）、数据控制语言（DCL）等。
2. 请说明如何创建一个简单的表，包括表结构、字段类型、约束等。
3. 请编写一个查询语句，查询某个表中所有年龄大于30岁的记录。
4. 请编写一个更新语句，将某个表中年龄大于40岁的记录的年龄加1。
5. 请编写一个删除语句，删除某个表中年龄小于20岁的记录。
6. 请编写一个插入语句，插入一条记录到某个表中。
7. 请说明如何使用SQL语句实现分页查询。
8. 请说明如何使用SQL语句实现多表查询。
9. 请说明如何使用SQL语句实现子查询。
10. 请说明如何使用SQL语句实现联合查询。
三、Oracle高级特性1. 请解释什么是视图？如何创建视图？2. 请解释什么是索引？有哪些常见的索引类型？3. 请解释什么是触发器？如何创建触发器？4. 请解释什么是存储过程？如何创建存储过程？5. 请解释什么是函数？如何创建函数？6. 请解释什么是包？如何创建包？7. 请解释什么是序列？如何创建序列？8. 请解释什么是同义词？如何创建同义词？9. 请解释什么是物化视图？如何创建物化视图？10. 请解释什么是分区表？如何创建分区表？四、Oracle性能优化1. 请说明如何查看Oracle数据库的性能统计信息。
oracle的TM锁T锁知识完全普及
oracle的TM锁、TX锁知识完全普及锁概念基础数据库是一个多用户使用的共享资源;当多个用户并发地存取数据时,在数据库中就会产生多个事务同时存取同一数据的情况;若对并发操作不加控制就可能会读取和存储不正确的数据,破坏数据库的一致性;加锁是实现数据库并发控制的一个非常重要的技术;当事务在对某个数据对象进行操作前,先向系统发出请求,对其加锁;加锁后事务就对该数据对象有了一定的控制,在该事务释放锁之前,其他的事务不能对此数据对象进行更新操作;在数据库中有两种基本的锁类型：排它锁Exclusive Locks,即X锁和共享锁Share Locks,即S锁;当数据对象被加上排它锁时,其他的事务不能对它读取和修改;加了共享锁的数据对象可以被其他事务读取,但不能修改;数据库利用这两种基本的锁类型来对数据库的事务进行并发控制;Oracle数据库的锁类型根据保护的对象不同,Oracle数据库锁可以分为以下几大类：DML锁data locks,数据锁,用于保护数据的完整性；DDL锁dictionary locks,字典锁,用于保护数据库对象的结构,如表、索引等的结构定义；内部锁和闩internal locks and latches,保护数据库的内部结构;DML锁的目的在于保证并发情况下的数据完整性,;在Oracle数据库中,DML锁主要包括TM锁和TX锁,其中TM锁称为表级锁,TX锁称为事务锁或行级锁;当Oracle 执行DML语句时,系统自动在所要操作的表上申请TM类型的锁;当TM 锁获得后,系统再自动申请TX类型的锁,并将实际锁定的数据行的锁标志位进行置位;这样在事务加锁前检查TX锁相容性时就不用再逐行检查锁标志,而只需检查TM锁模式的相容性即可,大大提高了系统的效率;TM锁包括了SS、SX、S、X 等多种模式,在数据库中用0－6来表示;不同的SQL操作产生不同类型的TM锁;在数据行上只有X锁排他锁;在 Oracle数据库中,当一个事务首次发起一个DML 语句时就获得一个TX锁,该锁保持到事务被提交或回滚;当两个或多个会话在表的同一条记录上执行 DML语句时,第一个会话在该条记录上加锁,其他的会话处于等待状态;当第一个会话提交后,TX锁被释放,其他会话才可以加锁;当Oracle数据库发生TX锁等待时,如果不及时处理常常会引起Oracle数据库挂起,或导致死锁的发生,产生ORA-60的错误;这些现象都会对实际应用产生极大的危害,如长时间未响应,大量事务失败等;悲观封锁和乐观封锁一、悲观封锁锁在用户修改之前就发挥作用：Select ..for updatenowaitSelect from tab1 for update用户发出这条命令之后,oracle将会对返回集中的数据建立行级封锁,以防止其他用户的修改;如果此时其他用户对上面返回结果集的数据进行dml或ddl操作都会返回一个错误信息或发生阻塞;1：对返回结果集进行update或delete操作会发生阻塞;2：对该表进行ddl操作将会报：Ora-00054:resource busy and acquire with nowait specified.原因分析此时Oracle已经对返回的结果集上加了排它的行级锁,所有其他对这些数据进行的修改或删除操作都必须等待这个锁的释放,产生的外在现象就是其他的操作将发生阻塞,这个这个操作commit或rollback.同样这个查询的事务将会对该表加表级锁,不允许对该表的任何ddl操作,否则将会报出ora-00054错误：:resource busy and acquire with nowait specified.二、乐观封锁乐观的认为数据在select出来到update进取并提交的这段时间数据不会被更改;这里面有一种潜在的危险就是由于被选出的结果集并没有被锁定,是存在一种可能被其他用户更改的可能;因此Oracle仍然建议是用悲观封锁,因为这样会更安全;阻塞定义：当一个会话保持另一个会话正在请求的资源上的锁定时,就会发生阻塞;被阻塞的会话将一直挂起,直到持有锁的会话放弃锁定的资源为止;4个常见的dml语句会产生阻塞INSERTUPDATEDELETESELECT…FOR U PDATEINSERTInsert发生阻塞的唯一情况就是用户拥有一个建有主键约束的表;当2个的会话同时试图向表中插入相同的数据时,其中的一个会话将被阻塞,直到另外一个会话提交或会滚;一个会话提交时,另一个会话将收到主键重复的错误;回滚时,被阻塞的会话将继续执行;UPDATE 和DELETE当执行Update和delete操作的数据行已经被另外的会话锁定时,将会发生阻塞,直到另一个会话提交或会滚;Select …for update当一个用户发出select..for update的错作准备对返回的结果集进行修改时,如果结果集已经被另一个会话锁定,就是发生阻塞;需要等另一个会话结束之后才可继续执行;可以通过发出select… for update nowait的语句来避免发生阻塞,如果资源已经被另一个会话锁定,则会返回以下错误：Ora-00054:resource busy and acquire with nowait specified.死锁-deadlock定义:当两个用户希望持有对方的资源时就会发生死锁.即两个用户互相等待对方释放资源时,oracle认定为产生了死锁,在这种情况下,将以牺牲一个用户作为代价,另一个用户继续执行,牺牲的用户的事务将回滚.例子：1：用户1对A表进行Update,没有提交;2：用户2对B表进行Update,没有提交;此时双反不存在资源共享的问题;3：如果用户2此时对A表作update,则会发生阻塞,需要等到用户一的事物结束;4：如果此时用户1又对B表作update,则产生死锁;此时Oracle会选择其中一个用户进行会滚,使另一个用户继续执行操作;起因:Oracle的死锁问题实际上很少见,如果发生,基本上都是不正确的程序设计造成的,经过调整后,基本上都会避免死锁的发生;DML锁分类表1.关于V$lock表和相关视图的说明Lock mode in which the session holds the lock:0 - none1 - null NULL2 - row-S SS3 - row-X SX4 - share S5 - S/Row-X SSX6 - exclusive X--大于0时表示当前会话以某种模式占有该锁,等于0时表示当前会话正在等待该锁资源,即表示该会话被阻塞;--往往在发生TX锁时,伴随着TM锁,比如一个sid=9会话拥有一个TM锁,一般会拥有一个或几个TX锁,但他们的id1和id2是不同的,请注意Lock mode in which the process requests the lock:0 - none1 - null NULL2 - row-S SS3 - row-X SX4 - share S5 - S/Row-X SSX6 - exclusive X--大于0时,表示当前会话被阻塞,其它会话占有改锁的模式2.其它相关视图说明select from v$lock;select from v$lock where block=1;2.查询被锁的对象select from v$locked_object;3.查询阻塞查被阻塞的会话select from v$lock where lmode=0 and type in 'TM','TX';查阻塞别的会话锁select from v$lock where lmode>0 and type in 'TM','TX';4.查询数据库正在等待锁的进程select from v$session where lockwait is not null;5.查询会话之间锁等待的关系select holdsid, waitsid,,,, from v$lock a,v$lock bwhere = and = and =1and =0;6.查询锁等待事件select from v$session_wait where event='enqueue';。
innodb底层原理
innodb底层原理InnoDB是一个开源的关系型数据库管理系统，由Oracle公司开发，作为MySQL的一部分。
它是一个高性能的存储引擎，被广泛应用于大规模的网站和应用程序中，并在生产和业务环境中得到广泛使用。
InnoDB的底层原理包括以下几个方面：1. 事务和锁机制InnoDB使用了多版本并发控制（MVCC）来实现事务支持和锁机制。
在MVCC中，每个事务都看到一个版本的数据，而不是实际的数据。
因此，每个事务都可以读取和修改不同版本的数据，而不与其他事务发生冲突，从而避免了锁的竞争。
2. 缓冲池InnoDB使用缓冲池来管理内存，将查询结果和修改操作缓存在内存中，从而提高了性能。
缓冲池是一个内存池，用于缓存表和索引的数据页。
3. 页结构InnoDB使用了固定大小的页来存储数据和索引。
每个页的大小默认为16KB，但可以通过配置文件进行修改。
页被组织为一个B+树结构，每个节点包含一个键值和一个指向下一个节点的指针。
4. 事务日志InnoDB使用了事务日志（redo log）来记录所有的修改操作，从而实现事务的持久性。
事务日志是一个循环缓冲区，包含多个日志文件，每个文件大小为1~2GB。
当一个事务提交时，相关的修改操作将写入事务日志中，而不是直接写入数据页。
5. 二次写InnoDB实现了二次写（double write）机制，用于保护数据页的完整性。
首先，InnoDB 将修改操作写入缓冲池中，然后再将其写入磁盘中。
如果写入磁盘过程中出现错误，InnoDB会使用二次写机制，将缓冲池中的数据重新写入磁盘。
6. 自适应哈希索引InnoDB使用了自适应哈希索引（adaptive hashing）来提高在缓冲池中定位数据的效率。
自适应哈希索引是一种特殊的哈希表，它存储在缓冲池中，并在之前使用过的数据页上创建索引，以及在新的数据页上动态创建索引。
7. 外键约束InnoDB支持外键约束，它可以确保关系型数据表之间的完整性。
oracle锁与死锁概念，阻塞产生的原因以及解决方案
oracle锁与死锁概念，阻塞产⽣的原因以及解决⽅案锁是⼀种机制，⼀直存在；死锁是⼀种错误，尽量避免。
⾸先，要理解锁和死锁的概念：1、锁：定义：简单的说，锁是数据库为了保证数据的⼀致性⽽存在的⼀种机制，其他数据库⼀样有，只不过实现机制上可能⼤相径庭。
那么，锁的种类有哪些？锁的种类有很多，根据保护的对象不同，Oracle数据库锁可以分为以下⼏⼤类：DML锁（data locks，数据锁），⽤于保护数据的完整性；DDL锁（dictionary locks，字典锁），⽤于保护数据库对象的结构，如表、索引等的结构定义；内部锁和闩（internal locks and latches），保护数据库的内部结构。
在实际项⽬中遇到的最多的是DML锁，也可进⼀步说是⾏级锁。
这些⾏级锁在程序并发访问的时候会造成程序很慢，或者直接访问不了的情况—这种现象称为阻塞。
那么，产⽣阻塞的原因是什么呢？定义：当⼀个会话保持另⼀个会话正在请求的资源锁定时，就会发⽣阻塞。
被阻塞的会话将⼀直挂起，直到持有锁的会话放弃锁定的资源为⽌。
四个常见的DML语句会产⽣阻塞：1）INSERT 2）U PDATE 3）DELETE 4）SELECT…FOR UPDATE2、死锁：定义：当两个⽤户同时希望持有对⽅的资源时就会发⽣死锁。
即当两个⽤户互相等待对⽅释放资源时，oracle认定产⽣了死锁，在这种情况下，将以牺牲⼀个⽤户为代价，另⼀个⽤户继续执⾏，牺牲的事物将回滚。
例⼦： 1：⽤户1对A表进⾏Update，没有提交。
2：⽤户2对B表进⾏Update，没有提交。
此时双反不存在资源共享的问题。
3：如果⽤户2此时对A表作update,则会发⽣阻塞，需要等到⽤户⼀的事物结束。
4：如果此时⽤户1⼜对B表作update，则产⽣死锁。
此时Oracle会选择其中⼀个⽤户进⾏会滚，使另⼀个⽤户继续执⾏操作。
起因: Oracle的死锁问题实际上很少见，如果发⽣，基本上都是不正确的程序设计造成的，经过调整后，基本上都会避免死锁的发⽣。
oracle解锁数据的方法
oracle解锁数据的方法
在Oracle数据库中，解锁数据的方法取决于锁定的类型和锁定的来源。
下面是一些常见的解锁数据的方法：
1. 手动提交或回滚事务：如果数据被锁定是因为当前事务没有完成，则可以手动提交或回滚事务，以释放锁定的数据。
可以使用以下命令提交事务：
```
COMMIT;
```
或者使用以下命令回滚事务：
```
ROLLBACK;
```
2. 等待其他事务完成：如果数据被其他事务锁定，则可以等待其他事务完成并释放锁定的数据。
3. 杀死会话进程：如果无法等待其他事务完成或无法识别锁定的来源，可以使用以下命令杀死锁定会话进程：
```
ALTER SYSTEM KILL SESSION 'sid, serial#';
```
其中'sid'和'serial#'是锁定会话的标识符，在V$SESSION视图中可以找到。
4. 重启数据库实例：如果数据长时间被锁定或无法解锁，可以考虑重启整个数据库实例来释放锁定的数据。
但是，这种解锁方法应该在其他方法失败后才使用，并且需要小心处理，避免数据丢失或影响其他正在进行的操作。
需要注意的是，解锁数据可能会引起数据一致性问题，必须谨慎使用。
在进行任何解锁操作之前，建议先备份数据以防止意外情况发生。
Oracle的锁有几种模式
Oracle的锁有几种模式
4：Share 共享锁(S): 阻止其他DML操作5：S/Row-X 共享行专用(SRX): 阻止其他事务操作6：exclusive 专用(X): 独立访问使用以上可以看出，数字越大的锁影响的操作越多，锁的级别越高。
一般的查询语句是小于2的锁，如select * from *select …from …for update 是2的锁，这时候返回集的数据行都将处于行级(Row-X)独占式锁定，其他对象只能对这些数据进行查询，而不能进行更新或者select for update操作。
insert/update/delete是3的锁，在这些操作没有commit之前插入同样的记录会没有反应，因为3的锁必须要等到前一个3的锁执行释放掉以后才能继续。
创建索引的时候也会产生3,4级别的锁。
locked_mod为2,3,4的锁，不影响DML （insert,delete,update,select）操作，但是DDL（alter,drop）等修改表结构的操作会提示ora-00054错误。
当有主外键约束时执行update/delete操作可能会产生4,5的锁。
DDL语句时是6的锁。
1。
Oracle教程13
②
若B1>B，从A1转出，B1=B1-B
如果B1<B，余额不足，取消操作
③
银行数据库
转入A2，此时，B2=B2+B
④
1-4
事务的ACID特性及实现
• • • • 原子性 一致性 隔离性 持久性
1-5
PL/SQL中事务的实现
• • • 事务的类型 提交事务 设置事务的保存点
1-6
事务的类型
• • 显式操作方式 隐式管理方式
1-7
并发控制及其实现
• • • • • • 并发访问的常见问题 什么是锁 锁的分类 事务隔离级别 事务阻塞及其解决方法 死锁
1-8
锁的分类
• • 排他锁 共享锁
1-9
性格决定命运, 专注成就人生
PLSQL宝典
第13章 事务和锁
课程安排
• • • 事务控制的基本概念 PL/SQL中事务的实现 并发控制及其实现
1-2
事务控制的基本概念
• • • •
事务控制的必要性 事务的ACID特性及实现 事务的状态 PL/SQL中事务的执行
1-3
事务控制的必要性
输入转出账户A1和转账金额B
①
从数据库读出账户A1中的余额B1
oracle 锁详解
oracle 锁详解在 Oracle 数据库中，锁（Lock）用于控制并发访问和确保数据的一致性。
锁是一种机制，它可以限制对特定资源（如表、行、记录等）的访问，以防止并发事务之间的冲突和数据不一致。
Oracle 中的锁可以分为以下几种类型：1. **共享锁（Shared Lock）**：也称为读锁，用于读取数据并确保多个事务可以同时读取相同的数据，而不会相互阻塞。
共享锁可以与其他共享锁共存，但与排他锁互斥。
2. **排他锁（Exclusive Lock）**：也称为写锁，用于对数据进行写入操作，并确保在同一时间只有一个事务可以获取排他锁。
排他锁会阻止其他事务获取共享锁或排他锁。
3. **行级锁 （Row-Level Lock）**：用于锁定表中的特定行，以提供更细粒度的并发控制。
行级锁可以是共享锁或排他锁。
4. **表级锁（Table-Level Lock）**：用于锁定整个表，阻止其他事务对表进行读写操作。
表级锁通常会影响并发性能，因此在 Oracle 中较少使用。
Oracle 数据库自动管理和协调锁的获取和释放。
在执行 DML （数据操作语言）语句时，Oracle 会根据需要自动获取适当类型的锁。
例如，在执行 SELECT 语句时，Oracle 会获取共享锁；而在执行 INSERT、UPDATE 或 DELETE 语句时，Oracle 会获取排他锁。
锁的粒度和类型可以根据事务的隔离级别进行设置。
Oracle 提供了多种隔离级别，如 READ COMMITTED、SERIALIZABLE 等，每个隔离级别都对应不同的锁行为。
了解和管理锁对于确保数据库的并发性能和数据一致性非常重要。
Oracle 数据库提供了一些视图和工具来监控和诊断锁的信息，例如 V$LOCK、V$SESSION 等视图。
如果在应用程序中遇到锁冲突或性能问题，可以使用这些工具来分析和解决锁相关的问题。
请注意，以上是 Oracle 锁的一些基本概念和类型，Oracle 数据库的锁机制非常复杂，并且还有其他更高级的锁类型和特性。
oracle行锁加锁规则
oracle行锁加锁规则Oracle行锁加锁规则是数据库管理中的一个重要概念。
行锁是一种锁定数据库表中某一行数据的机制，用于保证并发操作的数据一致性和正确性。
在使用Oracle数据库时，需要遵循一定的加锁规则，以避免数据错误或死锁的发生。
一、什么是行锁行锁是一种粒度较小的锁，它只锁定数据库表中的某一行数据，而不是整个表或数据库。
当一个事务对某一行数据进行修改时，会将该行数据加上行锁，其他事务在访问该行数据时需要等待行锁释放。
二、行锁加锁规则1. 事务开始时，需要明确要修改的行数据。
可以使用SELECT ... FOR UPDATE语句来获取需要加锁的行数据，并且开启事务。
2. 在事务中修改行数据前，需要使用SELECT ... FOR UPDATE NOWAIT语句对需要修改的行数据加锁。
如果无法获得行锁，则会立即返回错误信息，事务终止。
3. 在事务中修改行数据时，只能修改已加锁的行数据，否则会报错。
修改完成后，需要提交事务来释放行锁。
4. 在事务中获取行数据时，可以使用SELECT ... FOR SHARE语句对需要获取的行数据加锁。
这种锁是共享锁，不阻塞其他事务对该行数据的读取，但会阻塞其他事务对该行数据的修改。
三、行锁加锁规则的应用场景1. 并发事务的数据修改：当多个事务同时对同一行数据进行修改时，需要使用行锁来保证数据一致性。
2. 数据库的查询操作：当某个事务需要对查询结果进行修改时，可以使用行锁来避免其他事务对该行数据的修改。
3. 数据库的插入操作：当多个事务同时插入数据到同一张表中时，需要使用行锁来保证数据的完整性和准确性。
4. 数据库的删除操作：当多个事务同时删除同一行数据时，需要使用行锁来避免数据丢失或冲突。
总结：Oracle行锁加锁规则是数据库管理中的重要概念，它可以保证并发操作的数据一致性和正确性。
在使用行锁时，需要遵循一定的加锁规则，包括明确要修改的行数据、使用SELECT ... FOR UPDATE语句获取行锁、在事务中修改行数据和提交事务释放行锁等。
Oralce数据库对象
北京 湖南 湖北 张三 1 0 0 李四 0 1 0 王五 0 0 1 赵六 1 0 0 田七 0 1 0 王八 0 0 1
30
表分区
1范围分区 表里面有20000行数据 create table my ( id number(12) primary key ) partition by range (id) ( partition p1 values less than (10000) partition p2 values less than (20000) )
21
视图
视图以经过定制的方式显示来自一个或多个表的数据 视图可以视为“虚拟表”或“存储的查询” 创建视图所依据的表称为“基表” 视图的优点有：
提供了另外一种级别的表安全性，可指定对表中的一组行或列访 问 隐藏的数据的复杂性，如连接视图，表达式 简化的用户的SQL命令，如连接视图 隔离基表结构的改变， 通EATE SEQUENCE emp_sq create sequence 序列名称 ; INCREMENT BY 1 -- 每次加几个 该代码用于创建初值为1，增量为1，无限增长的序列。 START WITH 1 -- 从1开始计数 序列命名： sq_表名 NOMAXVALUE -- 不设置最大值 NOCYCLE -- 一直累加，不循环 CACHE 10 --内存缓存 访问序列
17
同义词
同义词是数据库对象的别名、引用。（这些对象可以是表、 视图、序列、过程、函数等） 同义词优点：
简化SQL语句（不需要用户前缀）。 隐藏对象的真实名称和所有者。 提供对对象的公共访问。
强调：
同义词 虽允许用户访问数据库对象，但不能替代权限，在使用同 义词之前要确保用户已得到访问对象的权限。 对同义词的所有操作将影响到其引用对象。
oracle数据库锁表解决方法
oracle数据库锁表解决方法Oracle数据库是一种强大的关系型数据库管理系统，广泛应用于各个行业中。
在使用Oracle数据库时，我们可能会遇到一些表锁的问题，即某个表被其他事务锁住，导致其他事务无法对该表进行操作。
本文将介绍一些解决Oracle数据库锁表的方法。
1. 查看锁表的情况在解决锁表问题之前，首先需要了解哪个表被锁住了。
我们可以通过查询数据库中的V$LOCK视图来查看当前的锁表情况。
V$LOCK 视图包含了已经获取或等待的锁的信息，可以通过查询该视图来获取锁表的详细信息，包括锁住表的会话ID、锁的模式、锁的类型等。
2. 杀死锁表的会话在确认了是哪个会话锁住了表之后，可以尝试杀死该会话，释放锁。
可以使用ALTER SYSTEM KILL SESSION命令来杀死指定会话。
需要注意的是，杀死会话可能会导致该会话正在进行的事务回滚，可能会对数据造成一定影响，因此在执行该操作前需要谨慎考虑。
3. 释放锁如果无法杀死锁表的会话，或者杀死会话后锁仍然存在，可以尝试使用ALTER SYSTEM KILL SESSION命令的IMMEDIATE选项来释放锁。
该选项会立即终止会话，并且回滚会话所属的事务。
该方法需要具有适当权限的用户执行。
4. 等待锁释放如果无法通过杀死会话或释放锁的方式解决锁表问题，可以选择等待锁的释放。
在Oracle数据库中，当一个事务请求锁时，如果锁被其他事务占用，该事务会被阻塞，直到锁被释放。
因此，可以等待锁的释放，待锁被释放后再进行操作。
5. 分析锁表原因在解决锁表问题时，还需要分析锁表的原因，以避免类似问题的再次发生。
常见的导致锁表的原因包括事务长时间占用锁、事务并发度过高、事务执行顺序不当等。
可以通过查看数据库的AWR报告或使用性能监视工具来分析锁表原因，并进行相应的优化。
6. 优化SQL语句在解决锁表问题时，还可以通过优化SQL语句来减少锁表的概率。
例如，可以尽量减少对同一表的频繁更新操作，可以使用合适的索引来提高查询效率，可以将大事务拆分为多个小事务等。
oracle行锁加锁规则
oracle行锁加锁规则
Oracle数据库中的行锁是通过使用SELECT ... FOR UPDATE语句或者使用LOCK TABLE语句来实现的。
行锁是用来保护数据行，防止其他事务对其进行修改或删除。
在Oracle中，行锁有一些规则和注意事项，让我们来逐一讨论：
1. SELECT ... FOR UPDATE语句，当你使用SELECT ... FOR UPDATE语句时，它会在查询结果集的行上加上排他锁，这样其他事务就不能修改或删除这些行。
需要注意的是，这种行级锁是在事务提交或回滚时释放的。
2. 锁的粒度，Oracle数据库的行锁是基于行的，也就是说，当你使用行级锁时，只有被查询的行会被锁定，而不是整个表或者整个数据页。
3. 事务隔离级别，行锁的行为还受到数据库事务隔离级别的影响。
在Oracle中，事务隔离级别包括READ COMMITTED、SERIALIZABLE等级别，不同的隔离级别对行锁的行为会有所影响。
4. 死锁，在使用行锁时，需要小心死锁的问题。
如果多个事务
同时尝试锁定相同的行，就有可能发生死锁。
为了避免死锁，需要
合理设计事务逻辑和锁定顺序。
5. 性能影响，行锁可能会对数据库性能产生影响，特别是在高
并发的情况下。
因此，需要在使用行锁时注意性能优化的问题，避
免出现性能瓶颈。
总的来说，Oracle数据库中的行锁是一种重要的并发控制手段，但需要在使用时注意锁的粒度、事务隔离级别、死锁和性能等方面
的问题，以确保数据库的并发访问能够得到有效控制和良好的性能
表现。
orcale默认事务隔离级别
orcale默认事务隔离级别摘要：1.Oracle数据库默认事务隔离级别介绍2.Oracle数据库的事务隔离级别3.事务隔离级别对数据库性能的影响4.如何根据业务需求调整事务隔离级别5.总结正文：1.Oracle数据库默认事务隔离级别介绍在Oracle数据库中，事务隔离级别用于控制多个并发事务同时访问相同数据时产生的问题。
默认的事务隔离级别是“READ UNCOMMITTED”，这意味着一个事务可以读取另一个未提交事务的数据。
2.Oracle数据库的事务隔离级别Oracle数据库提供了以下四种事务隔离级别：- READ UNCOMMITTED：读取未提交的数据，可能导致脏读（Dirty Read）。
- READ COMMITTED：读取已提交的数据，避免了脏读，但仍然存在不可重复读（Non-Repeatable Read）的问题。
- REPEATABLE READ：可重复读，避免了不可重复读，但仍然存在幻读（Phantom Read）的问题。
- SERIALIZABLE：串行化，提供最高级别的事务隔离，避免了脏读、不可重复读和幻读。
3.事务隔离级别对数据库性能的影响不同的事务隔离级别会对数据库性能产生不同的影响。
通常情况下，隔离级别越高，对性能的影响越大，因为需要更多的锁和资源来保证事务隔离。
在实际应用中，需要根据业务需求和性能考虑选择合适的事务隔离级别。
4.如何根据业务需求调整事务隔离级别在Oracle数据库中，可以通过以下方法根据业务需求调整事务隔离级别：- 使用`ALTER SESSION`命令为当前会话设置事务隔离级别。
- 使用`ALTER SYSTEM`命令为整个数据库设置事务隔离级别。
- 在表级别使用`WITH CHECK OPTION`子句限制外键参考完整性，以实现更细粒度的事务隔离控制。
5.总结Oracle数据库的默认事务隔离级别是“READ UNCOMMITTED”，但这并不是最佳选择，需要根据具体业务需求和性能考虑来调整事务隔离级别。
oracle排他锁写法
oracle排他锁写法在Oracle数据库中，排他锁（Exclusive Lock）用于确保在一个事务中对数据的修改不会被其他事务同时修改。
1.使用SELECT ... FOR UPDATE 语句这是在Oracle中获取排他锁的最常见方法。
通过使用 SELECT FOR UPDATE 语句，你可以锁定选定的行，直到当前事务结束。
这将锁定满足条件的行，防止其他事务对这些行进行修改或删除。
例句：SELECT column_name FROM table_name WHERE condition FOR UPDATE;2.使用事务控制在Oracle中，当你在事务中对表进行更新（如使用 UPDATE 语句）时，Oracle 会自动在被修改的行上设置排他锁。
这个锁会持续到事务结束（提交或回滚）。
例句：BEGINUPDATE table_name SET column_name = value WHERE condition;-- 其他数据库操作COMMIT; -- 或 ROLLBACK;在这个例子中，更新操作后的行会被锁定，直到事务提交或回滚。
3.使用DBMS_LOCK 包Oracle提供了 DBMS_LOCK 包，允许更细粒度的锁控制。
通过这个包，你可以创建自定义的排他锁例子：DECLARElockhandle VARCHAR2(128);result NUMBER;BEGINDBMS_LOCK.ALLOCATE_UNIQUE('my_lock', lockhandle);result := DBMS_LOCK.REQUEST(lockhandle, DBMS_LOCK.X_MODE);-- 执行需要锁定的操作result := DBMS_LOCK.RELEASE(lockhandle);END;在这个例子中，DBMS_LOCK.REQUEST 使用 DBMS_LOCK.X_MODE（排他模式）请求锁。
数据库事务、事务隔离级别以及锁机制详解
数据库事务、事务隔离级别以及锁机制详解以下主要以MySQL（InnoDB引擎）数据库为讨论背景，纯属个⼈学习总结，不对的地⽅还请指出！什么是事务？事务是作为⼀个逻辑单元执⾏的⼀系列操作，要么⼀起成功，要么⼀起失败。
⼀个逻辑⼯作单元必须有四个属性，称为 ACID（原⼦性、致性、隔离性和持久性）属性，只有这样才能成为⼀个事务。
数据库事物的四⼤特性（ACID）：1）原⼦性：（Atomicity）务必须是原⼦⼯作单元；对于其数据修改，要么全都执⾏，要么全都不执⾏。
2）⼀致性：（Consistency）事务在完成时，必须使所有的数据都保持⼀致状态。
在相关数据库中，所有规则都必须应⽤于事务的修改，保持所有数据的完整性。
事务结束时，所有的内部数据结构（如 B 树索引或双向链表）都必须是正确的。
3）隔离线：（Isolation）由并发事务所作的修改必须与任何其它并发事务所作的修改隔离。
事务查看数据时数据所处的状态，要么另⼀并发事务修改它之前的状态，要么是另⼀事务修改它之后的状态，事务不会查看中间状态的数据。
这为可串⾏性，因为它能够重新装载起始数据，并且重播⼀系列事务，以使数据结束时的状态与原始事务执的状态相同。
4）持久性：（Durability）事务完成之后，它对于系统的影响是永久性的。
该修改即使出现系统故障也将⼀直保持。
事务并发时会发⽣什么问题？（在不考虑事务隔离情况下）1）脏读：脏读是指在⼀个事务处理过程⾥读取了另⼀个未提交的事务中的数据。
例：事务A修改num=123------事务B读取num=123（A操作还未提交时）事务A回滚此时就会出现B事务读到的num并不是数据库中真正的num的值，这种情况就叫“脏读”。
2）不可重读：不可重复读是指在对于数据库中的某个数据，⼀个事务范围内多次查询却返回了不同的数据值，这是由于在查询间隔，被另⼀个事务修改并提交了。
例：事务A读取num=123（事务A并未结束）------事务B修改num=321，并提交了事务事务A再次读取num=321此时就会出现同⼀次事务A中两次读取num的值不⼀样，这种情况就叫“不可重读”。
oracle事务隔离级别查询语句
oracle事务隔离级别查询语句事务隔离级别是数据库管理系统中用来控制并发访问的特性。
Oracle数据库支持四种事务隔离级别，分别是读未提交（Read Uncommitted）、读已提交（Read Committed）、可重复读（Repeatable Read）和串行化（Serializable）。
下面将详细介绍这四种隔离级别的特点和查询语句的使用。
1. 读未提交（Read Uncommitted）隔离级别：读未提交是最低的隔离级别，事务可以读取其他事务未提交的数据。
这种级别的隔离级别可能出现脏读、不可重复读和幻读的问题。
查询语句：```sqlSET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED; SELECT * FROM table_name;```2. 读已提交（Read Committed）隔离级别：读已提交是Oracle数据库的默认隔离级别，事务只能读取已经提交的数据。
这种级别的隔离级别可以避免脏读的问题，但仍然可能出现不可重复读和幻读的问题。
查询语句：```sqlSET TRANSACTION ISOLATION LEVEL READ COMMITTED; SELECT * FROM table_name;```3. 可重复读（Repeatable Read）隔离级别：可重复读保证同一事务内多次读取同一数据时，结果始终一致。
在该隔离级别下，其他事务不能修改已经读取的数据，但可以插入新的数据。
查询语句：```sqlSET TRANSACTION ISOLATION LEVEL REPEATABLE READ; SELECT * FROM table_name;```4. 串行化（Serializable）隔离级别：串行化是最高的隔离级别，它通过加锁来保证事务的完全隔离。
每个事务在执行过程中都会对数据进行加锁，其他事务无法并发访问被锁定的数据。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
1、事务的概念：事务是一个基本的逻辑单元，它作为一个整体要么全部执行要么全部不执行。
2、事务的特性：原子性：事务是处理的一个原子单位，每一个操作不可拆分，它要么全部执行成功，要么全部都不执行。
一致性：指事务完成时，必须使所有的数据在整体上不变。
隔离性：各事务之间相互隔离，此事务的执行不受其他并发事务执行的干扰。
持续性：指事务对数据库的改变应是持续存在的，不会因故障而发生丢失。
3、从功能是上划分，sql语言分为DDL、DML和DCL：3.1DDL(Data Definition Language，数据定义语言)：用于定义和管理数据库中的所有对象的语言，如：create创建表空间、alter修改表空间、drop 删除表空间3.2：DML(Data manipulation Language，数据操作语言)：处理数据等操作，如：insert插入数据、delete删除数据、update修改数据、select查询数据3.3：DCL(Data Control Language，数据控制语言)：授予或回收访问数据库的权限，控制数据库操作事务发生的时间及效果，对数据库实行监视，如：grant授权，rollback回滚，commit提交4、事务的开始及结束：一个事务可以由一条DDL语句单独组成或多条DML语句共同组成。
一个事务从执行第一条sql语句开始，在它被提交或被回滚时结束。
事务的提交可以是显式提交：用commit命令直接完成；也可以是提交隐式提交：用sql语句间接完成提交，这些语句有：alter，audit，comment，create，disconnect，drop，exit，grant，noaudit，quit，revoke，rename，会话终止等；还可以是自动提交：set autocommit on或set autocommit immediate设置为自动提交，则在插入、删除、修改语句执行后自动提交，使用set autocommit off可以取消自动提交，show autocommit可以查看自动提交是否打开。
事务的回滚使用rollback;语句，可以为事务设置保存点，如：savepoint point1，然后使用rollback to [savepoint] point1回到保存点point1，若在point1后又设置了一个保存点savepoint point2，则在rollback to point1后将不能再回滚到point2，因为point2在point1的后面，point1的保存点不存在point2。
5、事务的并发性与一致性：并发性：多个用户可以在同一时刻访问相同的数据。
一致性：保证并发性的同时，每个用户能得到一致的数据视图。
并发执行事务时，可能发生如下情况：①脏读：某个事务读取了其他未提交事务修改过的数据。
脏读示例：提交读隔离级别可防止脏读，但不能防止不可重复读②不可重复读：某个事务读取一次数据后，其他事务修改了这些数据并进行了提交，这样当该事务重新读取这些数据时，就会得到与前一次读取不一致的结果。
简单的说，就是同样的条件，你读取过的数据，再次读取时发现值不一样了。
不可重复读示例：可重复读隔离级别可防止脏读和不可重复读又插入或删除了一些满足查询条件的记录，这样当该事务重新执行相同的查询时，会得到与前一次查询不一致的情况。
简单的说，就是同样的条件，第一次和第二次读出来的记录数不一样了。
幻象示例：④更新丢失：例如系统允许两个事务A、B同时更新同一数据50，A事务和B事务同时取得该数据，A事务将50加上50得到100，然后保存回数据库；而事务B将50加上100得到150，然后保存数据时覆盖了事务A保存的数据。
两个事务更新后的数据本该是200，而结果A更新的50丢失了。
6、解决数据脏读、不可重复读等问题的隔离级别：Oracle提供了三种隔离级别：Read Committed(提交读)、Serializable(串行读)、Read Only(只读)。
①Read Committed是Oracle默认隔离级别，若事务A先于事务B开始，事务B是Read Committed隔离级别，则不管事务A是哪种隔离级别，只要事务A未提交，事务B就会一直处于等待状态，直到事务A提交为止。
Read Committed消除了脏读，也不会丢失更新，但无法避免不可重复读和幻象读的发生。
②Serializable串行化隔离级别，确保事务顺序执行不被干扰，只要Serializable的事务在执行期间，其他事务要对其数据进行修改，便会发生无法序列化的访问错误，可以避免脏读、不可重复读、幻象、更新丢失，提供了最高级别的一致性，但并发性最低。
⑤Read Only只读隔离级别不允许在事务内对其进行修改或插入等更新操作。
Read Only 可以消除脏读。
SQL-92规范制定的4种隔离级别：☆未提交读(read uncommitted)☆提交读(read committed)☆可重复读(repeatable read)☆串行读(serializable read)总结：设置一个事务的隔离级别：SET TRANSACTION ISOLA TION LEVEL READ COMMITTED; --设置Read Committed级别SET TRANSACTION ISOLA TION LEVEL SERIALIZABLE; --设置Serializable级别SET TRANSACTION READ ONLY;--设置Read Only级别设置整个会话的隔离级别：ALTER SESSION SET ISOLA TION_LEVEL SERIALIZABLE;ALTER SESSION SET ISOLA TION_LEVEL READ COMMITTED;8、事务与锁锁机制用于管理对共享资源的并发访问，防止访问相同资源时发生的有害性交互。
基本上所有的锁都由oracle内部自动创建和维护，但是其中的DDL和DML锁是可以通过命令直接或间接管理的。
当事务在对某个数据对象进行操作前，先向系统发出请求，对其所访问的数据对象加锁，加锁后事务就对该数据对象有一定的控制，在该事务释放锁之前，其他事务不能对此数据对象进行更新操作。
Oracle提供的两种类型的锁机制：①独占锁：防止相关资源被共享，主要用来修改数据，只有在独占资源的事务释放独占锁后，其他事务才能对其资源进行操作。
②共享锁：允许相关资源的共享，依赖于所包含的操作，多个用户读数据可以使用共享锁。
Oracle中锁的类型：①内部级锁：由Oracle自动管理，以保护Oracle的内部结构。
②DDL级锁(字典/语法分析锁)：用于保护数据字典和数据定义改变时的一致性和完整性，由系统在对sql定义语句做语法分析时自动加锁，如该锁在使用create、drop、alter、truncate 语句时自动创建，以确保在执行过程中没有其他事务对资源进行访问。
DDL锁可分为三类：字典操作锁、字典定义锁、表定义锁。
③DML级锁：用于控制并发事务中的数据操作，保证数据的一致性和完整性，其锁对象是表或行，在事务开始时创建，事务提交或回滚时释放。
DML锁可以由用户以显式的方式加锁，也可以通过sql语句隐式加锁。
DML封锁技术：Ⅰ、共享方式的表封锁(share)：lock table 表名[,表名]… in share mode [nowait];共享方式的表封锁是对表中的所有数据进行封锁，该锁用于保护查询数据的一致性，防止其他用户对已封锁的表进行更新，其他用户只能对该表再施加共享方式的锁，而不能再对该表施加独占方式的锁。
共享该表的所有用户只能查询表中数据，不能更新，只能用sql语句加该锁。
如下方式可以释放该锁：commit或rollback语句，退出数据库，程序停止运行。
Ⅱ、独占方式的表封锁(exclusive)：lock table 表名[,表名]… in exclusive mode [nowait]; 独占方式的表封锁对表中的所有数据进行封锁，拥有该独占方式的表封锁的用户，既可以查询该表又可以更新该表，其他用户不能再对该表施加任何锁，其他用户只可以查询该表。
独占方式的表封锁还可以在执行DML语句insert、update、delete时隐式获得。
如下方式可以释放该锁：commit或rollback语句，退出数据库，程序停止运行。
Ⅲ、共享更新方式封锁(share update)：lock table 表名[,表名]… in share update mode[nowait];或者select 列名[,列名]…from 表名where 条件for update of 列名[,列名]… [nowait];共享更新方式封锁是对表的一行或多行进行封锁，也称为行级锁。
该锁使得用户可以查询也可以更新被封锁的数据行，其他用户只能查询，若其他用户想更新表的数据行，则必须也要加共享更新方式锁，但其他用户的更新必须在上一个用户提交或回滚后才行。
如下方式可以释放该锁：commit语句，退出数据库，程序停止运行。
10、死锁下例便是一个死锁：会话A更新表A会话B更新表B会话B更新表A--阻塞会话A更新表B--导致死锁Oracle处理死锁的方式：Oracle系统会自动发现死锁，并选择代价小的，即完成工作量最少的事务予以撤销，释放该事务所拥有的全部锁，让其他事务继续工作下去。
11、加锁的注意事项：①对于update、delete操作，应只封锁要做改动的行，在完成修改后立即提交。
②当多个事务正利用共享更新的方式进行更新，则不要使用共享封锁，而应采用共享更新锁，这样其他用户就能使用行级锁，以增加并行性。
③尽可能将对一个表的操作的并发事务施加共享更新锁，从而提高并行性。
④在应用负荷较高的期间，不宜对基础数据结构(表、索引、簇、视图)进行修改。
12、加锁语句：☆lock table 表名in 锁定模式mode [nowait];解释：锁定模式为share表示共享锁(允许加锁，不许修改)，为share update表示共享更新方式封锁，为exclusive表示独占锁(不许加锁，不许修改)，为row share表示行级共享锁(允许加锁，不许修改)，为row exclusive表示行级独占锁(不许加锁，不许修改)，为share row exclusive表示共享行级独占锁(对相应行加独占锁，对表加共享锁，其他事务可对其他行加独占锁)。
nowait选项表示锁未添加成功时，则返回并由用户决定等待还是去执行其他语句。
☆添加行级共享锁：select… from 表名 for update;☆create语句自动加共享锁，alter语句自动加独占锁，insert、update、delete语句自动添加行级独占锁。