oracle学习笔记锁基础原理

Posted 2022-11-22 新站

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了oracle学习笔记锁基础原理相关的知识，希望对你有一定的参考价值。

oracle学习笔记锁基础原理

这节课开始讲oracle的锁

oracle的锁里面有些原理性的地方我们会讲到
同时也会给大家做一些演示
同时也为大家准备了很多的sql语句
以后可以根据演示
去复制sql语句，直接去使用就可以

所以说首先来讲oracle的锁的一些的基本概念

一）oracle的并发

第一个
锁是干什么用的
oracle为什么需要锁
简单说一下

讲到这个地方的时候
就讲到oracle的一个不同与别的数据库的一个特性

我们知道oracle数据库来讲
内存里面有buffercache、sharedpool、logbuffer、pga
然后一堆的session
buffercache、sharedpool、logbuffer整个的是SGA
底下的硬盘中是dbf等文件

这时候对sga来讲
buffercache、sharedpool、logbuffer这三个空间叫SGA
也叫共享全局区
所有的进程都可以访问他们

后台进程可以访问他们
后台进程可以访问所有的空间所有的数据
serverprocession也可以同时访问这些数据

也就是对sga来讲
有非常多的进程可以同时访问它们
这叫并发

对oracle来讲
后台进程数量有限，十来个
而且它们的工作负载并不是非常重
但是oracle进程对oracle数据库来讲
最多的进程是serverprocess
就是一个会话一个连接一个session

一个session对应一个连接
一个连接对应一个serverprocess
正常情况下相对负载比较大的一个数据库
会有上百个serverprocess进程
只有十来个后台进程

这上百个加上这十来个
一百多个甚至二百多个、三百多个
然后同时来访问SGA
这就叫并发性

特别是对serverprocess来讲
serverprocess是代表用户去执行sql的
这个sql语句有可能负载很重
有可能会访问非常多的表和行

我们讲并发性的时候
主要讲的是serverprocess
主要讲的serverprocess的并发性

二）并发和锁的关系

并发的话当然好了
因为并发意味着可以同时操作

讲到这个地方的时候
可以这么来说一句话
oracle之所以能并发是因为oracle有锁
没有锁谈不上并发

同时我们又说了
因为有锁限制了并发

有点矛盾
没有锁就没有并发
当然了锁也会使得我们的并发受到一些的限制

当然了不是矛盾，这是一个对应的关系

所以说讲到锁必然会提到并发性的问题
这就是锁的作用
锁的作用就是来解决并发问题的

为什么需要并发，为什么并发就需要锁呢
举个例讲
对一块数据来讲
比如说一个serverprocess要修改这个数据
这时候它可以给这个数据加一个锁

另外一个进程就不能访问它

A进程把这个数据给锁住了
B进程想要修改它的时候
需要等待A进程修改完
A就给这个数据加了一个锁

我们看因为有锁
所以说A和B可以同时运行
因为A运行的时候可以把数据锁住
B可以去做别的，等一会过来修改数据

因为有锁所以可以并发

同时我们看
因为锁的问题
A和B不能同时修改这个数据
锁限制了并发

三）用户的感觉

有一次用户给老师讲
说数据库里面都是锁，很多锁
是不是数据库出问题了
老师说不对的
数据库里面有锁是正常的
没有锁才奇了怪了

数据库有锁是正常的
关键是什么不正常呢
是一个进程等待一个锁这是正常的
一个进程等待一个锁
关键是等待时间不要过长

举例讲
A进程访问这个数据，锁上了
B进程也要访问这个数据，它等待
等待很正常，关键不要让B等待的时间太久

如果B等待的时间太久的话
这时候用户就会感觉
数据库跟死掉一样

提到锁我们主要讲的是serverprocess的锁

A进程上来以后锁住一块数据
B进程上来以后也要访问这个数据
它需要等待A解锁
A解锁以后B才能访问这个锁

这个时候
对B这个进程所对应的用户X用户在使用B进程
数据库可能目前为止几乎没有什么负载
只有这两个进程登上来了
但是他们在同时访问一块数据

这块数据被A进程访问了
B进程就在等待
这个时候X用户就感到数据库非常的慢

也就是说
A锁住了某个资源，B等待这块资源

这个时候B用户就会感到
这个连接这个操作非常的慢
这个慢可能不是慢
是它在等待
但是我们的体会上是慢

我们举个很简单的例子

为了体验
课程中老师给大家开了几个连接
有Oracle SQL Developer的几个链接和sqlplus的几个链接

告诉大家怎么去做这个事情，怎么开连接
我们新开一个sqlplus
用sqlplus虽然说简单一些
但是它反馈一些问题

在远程控制putty软件新开一个oracle的sqlplus客户端

login as: root
root@192.168.3.47's password:
Last login: Mon Nov 13 07:46:32 2017
[root@redhat4 ~]# su - oracle
[oracle@redhat4 ~]$ sqlplus hr/hr

SQL*Plus: Release 10.2.0.1.0 - Production on Thu Nov 16 10:25:10 2017

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


Connected to:
Oracle Database 10g Enterprise Edition Release 10.2.0.1.0 - Production
With the Partitioning, OLAP and Data Mining options

SQL>

再另一个putty再开一个sqlplus客户端

[oracle@redhat4 ~]$ export NLS_LANG=american_america.zhs16gbk
[oracle@redhat4 ~]$ sqlplus hr/hr

SQL*Plus: Release 10.2.0.1.0 - Production on Thu Nov 16 10:27:46 2017

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


Connected to:
Oracle Database 10g Enterprise Edition Release 10.2.0.1.0 - Production
With the Partitioning, OLAP and Data Mining options

SQL>

我们看在其中一个执行

SQL> select * from employees where rownum=1;

EMPLOYEE_ID FIRST_NAME           LAST_NAME
----------- -------------------- -------------------------
EMAIL                     PHONE_NUMBER         HIRE_DATE    JOB_ID
------------------------- -------------------- ------------ ----------
    SALARY COMMISSION_PCT MANAGER_ID DEPARTMENT_ID
---------- -------------- ---------- -------------
        198 Donald               OConnell
DOCONNEL                  650.507.9833         21-JUN-99    SH_CLERK
      2600                       124            50

第一行
我们找一个EMPLOYEE_ID
这里是198

我们去找一个update的sql语句我们来作一下
我们对employees表进行更新
如：
update employees set last_name=last_name||’a’ where department_id=60;

这里有两个sqlplus会话

其中一个去更新

SQL> update employees set last_name=last_name||'a' where department_id=60;

5 rows updated.

感觉速度非常的快
我们现在数据库基本上没有什么负载

在另外一个sqlplus中也更新相同的数据

SQL> update employees set last_name=last_name||'a' where department_id=60;

这个命令一回车以后
感觉执行不完一样
这个会话就感觉数据库特别的慢
等了这么长时间还没更新完

其实这时候
数据库这个慢是因为被锁住了

所以说就出一个问题
你看上去慢，用户感觉慢的时候
不一定数据库是负载很重
有可能是因为锁的问题

在以后讲优化的时候还会进一步去判断

怎么去释放锁呢

rollback和commit都可以释放锁

在第一个会话中执行回滚

SQL> rollback;

Rollback complete.

这时看第二个会话

SQL> update employees set last_name=last_name||'a' where department_id=60;

5 rows updated.

SQL>

命令得到执行了

说明释放完了锁，第二个会话执行的命令马上就过来了

这里为了继续做实验把第二个会话也回滚了

SQL> rollback;

Rollback complete.

讲到这个地方给大家讲了一个概念
产生锁的问题的时候
有锁是正常的
问题是不要因为锁而让进程等待时间过长
如果等待过长
这时候就有用户会感觉到数据库非常的慢
自然需要我们去解决

这是讲的锁的基本概念

锁的作用就是保护数据

四）数据库内存结构中的latch锁

那么oracle数据库里面又有哪种锁

总体来讲有两种锁
一种是latch锁，一种是LOCK锁

在oracle数据库里面
有哪些东西需要保护需要并发保护呢

第一种我们讲是chain链

我们讲过在内存里面
包括sharedpool里面，包括buffercache里面
有很多数据块，有很多的chunk
它们被串在各种各样的链上
比如说有个CBC（cache buffer chain）链挂着buffer
有sharedpool链挂着chunk

对这些链来讲
链底下挂着一些buffer或者一些chunk

当一个serverprocess要访问链上的chunk的时候
它需要访问这个链
在链上进行遍历
遍历以后找到这个chunk

也就是说在oracle数据库里面
一些内存结构，这些链
会被serverprocess并发访问

要并发访问这些链的话
这些链就需要保护
用latch来保护
老师只讲到这个地方
因为关于latch的问题要放到优化里面去讲

oracle数据库里面
数据库打开以后
在SGA里面有各种各样的链
这些链会被serverprocess并发访问
尽然会被并发访问，这些链就需要被保护

所以说一个serverprocess
在访问这个链的时候会获得这个链的锁
这个链的锁叫latch

获得这个链的这个锁就是获得latch
获得latch以后对这个链进行访问
访问完了自动释放latch

oracle里面有一个概念叫latch争用
这个在优化里面会详细的讲
老师会给大家讲有很多种类型的latch
和前面的体系结构是紧密的连接在一起的

发生latch争用的时候
说明有多个serverprocess同时对链进行访问
那说明出现了热块
或者比较热的一些chunk、热的sql语句、热的一些buffer、热块等等这些
我们需要一步步去排错

latch是用来保护链的
latch争用就是说明对链产生了争用

我们会在优化里面给大家解释和解决这个问题

oracle第一种锁是latch锁
它保护的是链

五）lock锁

oracle还有另外一种锁叫lock锁
这是我们这次课研究的重点

latch往往跟优化有关系和性能有关系
记住latch是保护chain也就是链

oracle还有另外一种叫lock锁
这个锁主要是用来保护buffer的
保护数据块数据行
这是我们这次讲的锁LOCK锁

锁有两种

一种叫排它锁

对一块资源来讲
A要访问它
给这个资源加了个排它锁
排它锁往往用X来表示
这时B就不能访问它
这叫排它锁

共享锁是
A访问这个资源加了个锁，加了共享锁
B也可以访问它，也可以加共享锁
也就是两个共享锁是兼容的
这个资源它有两个锁
两个共享锁

简单先记住
锁有两种
有共享锁有排它锁

latch是用来保护链的
lock是用来保护数据块数据行的
当然这个保护是保护并发访问

六）行级锁

我们在前面讲过oracle有行级锁
这是oracle的特性之一

我们知道一个事务开始的时候

事务表里面有一行它指向回滚块

然后数据块里面有事务槽
然后修改数据块里面的一行的时候
行的头部要加上一个锁标记

其实锁标记的数字
指向数据块里面的事务槽的槽的编号

数据块中一个事务槽又指向undo段头块中的事务表中的一行
undo段头块的事务表中的一条记录又指向回滚块
数据块中的事务槽中的一条记录也指向回滚块

这个是对应关系是我们前几节课讲的

oracle在访问这个行的时候加上了一个行级锁

对这个数据块来讲
A事务要修改数据块中的这个行
B事务要修改这个块里面的另一行的时候
它可以也获取到这个数据块中的一个事务槽
然后修改这个另一行
B事务修改的这个行指向事务槽中分配给B的那行事务槽

也就是说oracle
通过在一个数据行前面加上一个锁标记
实现了行级锁

也就是oracle对数据lock锁最小的粒度单位是行
我要访问那个行
就给这个行加上一个锁
当然这个访问叫DML，是修改，增删改
这就是一个粒度的概念

对于微软的sqlserver这个数据库
它的粒度是一个配置叫页
也就是我们讲的block

sqlserver要访问某个行的时候
它至少把这个行所在的整个块这个页给锁住
锁住的话里面的别的行即使没被修改也锁住了
sqlserver并发性在这方面就表现的很差

这是关于一个粒度的问题
oracle锁的粒度是行
这是第一个特点

其实还有一个很重要的概念
当一个事务修改一个数据行的时候
不影响另外一个select对这个行进行访问
也就是说我修改这个数据的时候
加了个X锁排它锁
不影响对这个数据块和这个数据行的读
因为我们可以构造cr块
这也是oracle的一个特性特点
一个非常有特色的地方

就是我对数据行的修改
不影响另外一个事务或另外一个访问
对这个数据行的一个读
这就是oracle的第二个特点

所以说oracle在锁上实现了行级锁
同时通过构造cr块这个行级锁又不影响对这个行的访问
这就是oracle并发性非常好的最主要的原因

这比sqlserver它们要好的多
这是我们讲了行级锁

行级锁主要是DML语句产生的

七）事务锁

有一个叫事务锁的概念

首先我们看看什么叫事务锁

我们知道一个事务开始
首先来讲一个事务它会产生一个事务锁

当然这个事务可能会修改很多的行
每行要叫行级锁
但是只有一个事务锁，因为它只有一个事务

我们可以查
举个例讲

这有三条sql语句：

update employees set last_name=last_name||'a' where department_id=60;
update departments set department_name='unknow' where department_id=10;
update locations set city='unknown' where location_id=1100;

组成一个事务

它修改了非常多的行
但是查以后发现
比如说这三个sql语句修改了十行
这时候它只有一个事务锁

讲到这个地方的时候再给大家来讲什么叫事务锁

首先事务锁是因为一个事务
一个事务有一个事务锁

事务锁是因为行级锁产生的
但是一个事务只有一个事务锁
它是因为行级锁产生的

先记住一个事务只能产生一个事务锁
这个事务是因为行级锁产生的

事务锁的加锁和解锁
很简单commit和rollback就解锁了
加锁就是DML语句
有了行级锁就会产生TX锁
一个事务有了行级锁就有了事务锁

有的时候我们把行级锁和事务锁给混了
其实它不一会事

行级锁是每个行上加一个锁
事务锁是一个事务一个锁
但是事务锁是因为行级锁产生的

我们查一下目前有没有事务
在sqldeveloper中执行
select xidusn,xidslot,xidsqn,status from v$transaction;
老师做的实验环境速度非常的慢，最后没等到结果

这个实验我自己做的结果

一开始执行update前没有事务

SQL> select xidusn,xidslot,xidsqn,status from v$transaction;

no rows selected

HR用户执行了一条update语句

SQL> update employees set last_name=last_name||'a' where department_id=60;

5 rows updated.

产生了事务

SQL> select xidusn,xidslot,xidsqn,status from v$transaction;

    XIDUSN    XIDSLOT     XIDSQN STATUS
---------- ---------- ---------- ----------------
         7         35        223 ACTIVE

hr用户再接着执行另外两个update
就是同一会话中同时对三个表执行三个不同的update

SQL> update employees set last_name=last_name||'a' where department_id=60;

5 rows updated.

SQL> update departments set department_name='unknow' where department_id=10;

1 row updated.

SQL> update locations set city='unknown' where location_id=1100;

1 row updated.

这时v$transaction中仍是只有一个事务

SQL> select xidusn,xidslot,xidsqn,status from v$transaction;

    XIDUSN    XIDSLOT     XIDSQN STATUS
---------- ---------- ---------- ----------------
         7         35        223 ACTIVE

老师的sqldeveloper实验中
会话长了它会自动的断开
所以说每次访问的时候它会自动的去连
所以说速度会慢一些
又开了三个sqldeveloper所以说速度很慢

我们知道行级锁并不影响我们去构造cr块
并不影响读

八）表级锁

除了行级锁、事务锁以外还有种锁叫表级锁
在表的级别上加一个锁
有时候我们还是需要表级锁的

我们知道oracle主要的锁是行级锁
修改那个行就加那个锁
同时因为事务会产生事务锁

我们来看还有一个表级锁叫TM

表级锁：TM

行级排他锁（Row exclusive）RX锁
    当我们进行DML时，会自动在被更新的表上添加RX锁，可以执行LOCK命令显式的在表上添加RX锁
    允许其他事务通过DML语句修改相同表里的其他数据行
    允许使用lock命令对表添加RX锁定
    不允许其他事务对表添加X锁
行级共享锁（Row Shared，简称RS锁）
    select … from for update
共享锁（Share，简称S锁）
    通过lock table in share mode命令添加该S锁
排他锁（Exclusive，简称X锁）
    通过lock table in exclusive mode命令添加X锁
共享行级排他锁（Share Row Exclusive，简称SRX锁）
    通过lock table in share row exclusive mode命令添加SRX锁

lock table  in [row share][row exclusive][share][share row exclusive][exclusive] mode;

表级锁里面又分5种

一种行级排它锁
它是一种表级锁RX锁
这个锁最多

一个表里面假设有十万行
A事务上来以后修改了表里面其中的一行
也就是给这个行加了X锁是行级锁
同时这个A产生了一个事务锁TX

A事务假设它修改了很多的行
每一行前面都加了一个行级锁
但是这个A事务只产生一个TX锁

这个时候B会话上来以后
它要把整个表删掉
oracle至少需要保证
这个表上所有的事务都提交了

这个时候B就需要

一种方法
B把所有的行统统读一遍
读一遍以后确认所有的行都提交了
然后再删除这个表

这时候有个问题

这里面我们看有十万行
有可能有非常多的事务在访问

这时候对B来讲
要把这十万行都访问一遍
然后确认这里面有没有人、有那个事务
有没有事务在其中修改某一行
做起来很困难

十万行它要一行行去查
要是一百万行
这时候对B来讲
他可能检查后面十万行的时候
前面十万行又被修改了

所以说对B来讲
要实现这个操作很麻烦

为了解决这个问题
oracle就做了这么个事情

A事务
要修改这个表里面的某一行或多行数据的时候
这个行加行级锁
同时这个A又产生了一个事务锁
同时另外一个地方
A这个事务
还在表的级别上加了一个TM锁
加了个表级锁
这个表级锁的名字叫RX

A事务刚才做了一件事情以后
产生了三个锁

一个锁是在这个行上加了个行级锁
同时A事务自己产生了一个TX锁事务锁
同时A这个事务还在这个表的级别上加了个TM
TM就是表级锁
这个锁的名字叫RX
RX锁是个表级锁

它是因为对这个表里面的某一行或多行进行的修改
而产生的RX锁

有一个C事务也要修改这个表里面的一行或多行
它也会做一件什么事情
第一它要对修改的行加上行级锁
同时也产生TX锁
还会给这个表加RX锁

A事务已经对这个表加了RX锁了
B事务也可以对这个表加RX锁
这就是锁和锁之间的兼容性的问题

在一个表上在一个资源上加了共享锁
还可以再加第二个共享锁
这里面的RX一样

加共享锁后再可以加共享锁
因为共享锁和共享锁是兼容的
所以说锁有兼容性的问题

我在一个资源上加了一个锁
另外一个会话上来以后
在这个资源上还可以加锁的时候
说明这两个锁是兼容的

A事务加了RX锁，在这个表加了RX锁
B事务和C事务上来以后在表上还可以加RX锁
也就是RX锁和RX锁是兼容的
虽然带了X但它是兼容的
这是表级锁

既然表级别上加了RX了
这个时候对B这个会话它要删除表的时候
它不需要关心表里面的行有没有加锁
因为这个表上已经加了表级锁了

B这个会话只要查一下这个表上有没有表级锁
使用表级锁就可以了
它一看有RX锁有表级锁
这时候它不能把这个表删除

因为B要删除这个表的话
需要对这个表加一个X锁
加个完全排它锁
因为这个表上已经有RX了
RX和X是互斥的，有RX就不能有X
所以说这时候B用户B会话不能删除这个表

不能删除表是因为表级别上有RX锁
这是这个概念

现在理解了吧
记住很有意思

九）表级锁的模式

1）RX锁、行级排它锁

一般的情况我们对表进行DML的时候
这时候oracle自动的对这个表加一个锁名字叫RX

记住RX是因为DML产生引起的
但是它是个表级锁

同时我们还可以用lock命令对表加RX锁

1、行级排他锁（Row exclusive）RX锁

当我们进行DML时，会自动在被更新的表上添加RX锁，可以执行LOCK命令显式的在表上添加RX锁

比如说
lock table 表的名字 in row exclusive mode;

就是在表上加RX锁
RX和RX可以兼容

2、允许其他事务通过DML语句修改相同表里的其他数据行
两个事务可以同时给某个表加RX

3、允许使用lock命令对表添加RX锁定
刚才讲了

4、不允许其他事务对表添加X锁
我们对表加X锁是因为要删除这个表
也就是说RX和X是互斥的

2）RS锁

对表TM除了有RX锁以外
还有行级RS锁行级共享锁

有一个语句
select … from for update
这个语句在实际生产里面很多人使用

select正常的不加锁
select for update是加锁的

我们看select for update的一个过程

首先来讲select for update 会产生一个事务
会产生事务就会在事务表里面产生一行
然后有回滚块
然后数据块
数据块里面的事务槽
和数据块里面修改的这一行

select for update是访问这行
但是行上加了锁
所以说select for update
和普通的DML语句一样
都会产生这一系列的东西
只不过select for update实际没有修改
但它锁住了这个行了

select for update 它读的是这行
但是是以DML的形式去读的这一行，也加锁了
它和普通DML不一样的是
它在表的级别上它加了RS锁，它没有加RX
就是这个区别

如果我对这行进行for update的时候
另外一个不能对这个行for update
因为for update和for update在行上是互斥的

举个例子

我们直接去做一个
select * from employees where rownum=1 for update;

在第一个sqlplus中的执行结果

SQL> select * from employees where rownum=1 for update;

EMPLOYEE_ID FIRST_NAME           LAST_NAME
----------- -------------------- -------------------------
EMAIL                     PHONE_NUMBER         HIRE_DATE    JOB_ID
------------------------- -------------------- ------------ ----------
    SALARY COMMISSION_PCT MANAGER_ID DEPARTMENT_ID
---------- -------------- ---------- -------------
        198 Donald               OConnell
DOCONNEL                  650.507.9833         21-JUN-99    SH_CLERK
      2600                       124            50

访问了employees中的其中第一行
然后加了个for update

我们在第二个地方第二个sqlplus中执行

SQL> select * from employees where rownum=1 for update;

指令暂时得不到结果
出现问题了，锁住了

如果第一个sqlplus中rollback

SQL> rollback;

Rollback complete.

这时第二个sqlplus中刚才等待的命令得到了执行

SQL> select * from employees where rownum=1 for update;

EMPLOYEE_ID FIRST_NAME           LAST_NAME
----------- -------------------- -------------------------
EMAIL                     PHONE_NUMBER         HIRE_DATE    JOB_ID
------------------------- -------------------- ------------ ----------
    SALARY COMMISSION_PCT MANAGER_ID DEPARTMENT_ID
---------- -------------- ---------- -------------
        198 Donald               OConnell
DOCONNEL                  650.507.9833         21-JUN-99    SH_CLERK
      2600                       124            50

返回了结果
第二个访问了

第二个也给rollback

SQL> rollback;

Rollback complete.

这就是select for update

就是刚才select for update一行的时候
也是在行上加锁、产生事务等等这些都一样
只不过select for update在表级别上加了个RS锁没有加RX
就这一个区别，别的都一样

这是表级共享锁

表的
行级共享锁（Row Shared，简称RS锁）
select … from for update

是因为select for update 产生的

3）其它几种表级锁

表上还可以加共享锁

共享锁（Share，简称S锁）
通过lock table in share mode命令添加该S锁

还可以加排它锁

排他锁（Exclusive，简称X锁）
通过lock table in exclusive mode命令添加X锁

记住排它锁的最经典的一个标志是
对表的结构进行改变或者把这个表删除
这时候就需要对这个表加排它锁
这个时候任何人任何用户
都不能对这个表有任何的修改
这是排它锁

我们可以用lock加

还有共享行级排它锁

共享行级排他锁（Share Row Exclusive，简称SRX锁）
通过lock table in share row exclusive mode命令添加SRX锁

这时候后面几个锁
真的有时候不太理解
排它锁还可以理解
有什么共享锁、共享行级排它锁
我们有时候不太理解

记住研究锁的时候从几个点上研究

第一个锁和锁之间的兼容性问题
第二锁是怎么产生的

oracle搞这么多的锁出来
其实就是为了锁数据的时候用
比如锁越多，分的越细
我锁某个资源的时候
可以选择的锁就越多
可以最小限度的减少锁的粒度

比如举例讲
咱们没有这些没有别的锁
比如说oracle数据库里面
什么锁都没有
只有一个表级别的一个排它锁
连DML这事务锁都没有
只有一个锁

那意味着
我要对这个表进行任何访问的时候
都需要加X锁
这个时候并发性会很差

所以说oracle就研究出来这么多的锁
目的是
研究出来的锁越来越多
每种锁有每种锁的兼容性
对某个表加锁的时候就可以非常灵活
最大限度的来减少锁对数据的影响

研究这么多的锁
特别是后面几种锁
共享锁、共享行级排他锁这后面这几种锁
有的人不太理解搞了加上这么多锁什么时候用
你总会用到

我们用什么锁关键是
我要锁什么资源
我锁的粒度是什么然后去选择相应的锁

在实际工作中总会用到

所以说用锁的时候
考虑我要锁什么资源
我锁的粒度是什么
锁多少
这时候自然就会找相关的锁

所以说这些锁
只要记住
锁越多，分的越细
那么将来我要锁资源的时候
可以选的就越多
那么它产生的一种并发的一种影响就越小
记住这个就行了

我们平时用的最多的是
行级锁、事务锁
这是我们平时涉及到最多的

再就是还有
表级别的RX锁还有RS锁
还有排它锁

这是我们平时接触最多的

共享锁、共享行级排它锁
用的相对比较少一些

十）锁的兼容性和加锁语句

对着兼容性就可以以后加锁的时候要注意一些

就可以知道
哪些锁可以兼容哪些锁不能兼容

所谓的兼容是两个锁可以同时在一个资源上加上

-	S	X	RS	RX	SRX	N/A
S	√	×	√	×	×	√
X	×	×	×	×	×	√
RS	√	×	√	√	√	√
RX	×	×	√	√	×	√
SRX	×	×	√	×	×	√
N/A	√	√	√	√	√	√

表级锁之间的兼容性，有了这个锁，能不能有另外一个锁。

对RX来讲
RX锁和RX锁是兼容的
也就是
表上我加了RX锁还可以继续加RX

如果在表上加了RS了
在这个表上我可以同时加RS和RX
我对这个表 select for update
还可以继续对这个表select for update
同时我还可以对这个表进行DML
因为它都是兼容的

我们看表级别的X锁
它和表所有的锁都是排它的
也就是说
只要这个表上有任何一个锁都不能加X
当然了你加了X以后
任何锁都不能再加了

这就是表锁的兼容性

如果对表加了X的话对并发影响最大

这是这些锁
锁的兼容性的问题

还有加锁语句
各种锁是如何产生的

SQL语句	表锁定模式	允许的表锁定模式
Select * from (table_name)……	无	RS、RX、S、SRX、X
Insert into (table_name)……	RX	RS、RX
Update ( 以上是关于oracle学习笔记锁基础原理的主要内容，如果未能解决你的问题，请参考以下文章 oracle学习笔记锁相关视图及相关操作 oracle学习笔记锁相关视图及相关操作如何在oracle数据库中的表里批量插入记录 oracle学习笔记网络原理及配置 oracle学习笔记网络原理及配置 JVM性能调优与底层原理分析(学习笔记) (c)2006-2024 SYSTEM All Rights Reserved IT常识

SQL语句

表锁定模式

允许的表锁定模式

Select * from (table_name)……

无

RS、RX、S、SRX、X

Insert into (table_name)……

RS、RX

Update (

以上是关于oracle学习笔记锁基础原理的主要内容，如果未能解决你的问题，请参考以下文章

oracle学习笔记锁相关视图及相关操作

如何在oracle数据库中的表里批量插入记录

oracle学习笔记网络原理及配置

JVM性能调优与底层原理分析(学习笔记)

-	S	X	RS	RX	SRX	N/A
S	√	×	√	×	×	√
X	×	×	×	×	×	√
RS	√	×	√	√	√	√
RX	×	×	√	√	×	√
SRX	×	×	√	×	×	√
N/A	√	√	√	√	√	√

-	S	X	RS	RX	SRX	N/A
S	√	×	√	×	×	√
X	×	×	×	×	×	√
RS	√	×	√	√	√	√
RX	×	×	√	√	×	√
SRX	×	×	√	×	×	√
N/A	√	√	√	√	√	√

oracle学习笔记 锁基础原理

oracle学习笔记 锁基础原理

一）oracle的并发

二）并发和锁的关系

三）用户的感觉

四）数据库内存结构中的latch锁

五）lock锁

六）行级锁

七）事务锁

八）表级锁

九）表级锁的模式

1）RX锁、行级排它锁

2）RS锁

3）其它几种表级锁

十）锁的兼容性和加锁语句

oracle学习笔记锁基础原理

oracle学习笔记锁基础原理

-	S	X	RS	RX	SRX	N/A
S	√	×	√	×	×	√
X	×	×	×	×	×	√
RS	√	×	√	√	√	√
RX	×	×	√	√	×	√
SRX	×	×	√	×	×	√
N/A	√	√	√	√	√	√