9-pg内核之锁管理器（四）常规锁

概述

常规锁是数据库中实现的锁，它和自旋锁及轻量锁不同，自旋锁和轻量锁属于系统锁，主要用于保护数据库系统中的一些关键变量，服务于数据库内核的实现；常规锁属于事务锁，主要用于协调各种不同事务对数据库对象如表、页、元组等的并发访问。

内存结构

锁模式

常规锁根据其不同的使用场景，分为了8中锁模式，每种模式权限不同，这样就可以在不同的场景下通过申请不同模式的锁，从而控制锁的权限。

• AccessShareLock
  访问共享锁，查询时会自动施加到被查询的表上。
• RowShareLock
  行共享锁，当SQL语句中采用了select…for update 和for share语句时将使用行共享锁对表加锁。
• RowExclusiveLock
  行排他锁，使用IUD语句时将使用行排它锁对表加锁，但只是一个意向锁，表明有事务对该表尽显IUD操作而已，并不会真正对行加锁，行锁另有其他的实现方法。
• ShareUpdateExclusiveLock
  共享更新排它锁，使用vacuum或者create index concurrently语句时使用该锁。
• ShareLock
  共享锁，使用不带concurrently选项的create index语句请求时用共享锁对表加锁。
• ShareRowExclusiveLock
  共享行排它锁，类似与排它锁，但是允许行共享。任何数据库命令都不会请求这个锁，除了lock命令。如，lock table tb1 in share row exclusive mode
• ExclusiveLock
  排它锁，阻塞行共享和select…for update语句。数据库中不会再用户表上自动请求这个锁，但是再系统表的可能会请求这个锁。
• AccessExclusiveLock
  访问排它锁，执行alter table， truncate ，reindex,cluster,drop table 以及vacuum full等SQL命令时会添加该锁，是最高级别的锁。

锁的相容性矩阵

常用锁结构

常规锁主要保存在4个位置：

• 主锁表： 在共享内存中，保存了一个锁对象的所有相关信息
• 进程锁表：在共享内存中，保存了一个锁对象与当前进程的所有相关信息
• 快速路径：在当前进程中，保存了弱锁的信息，避免频繁重复访问主锁表和进程锁表。
  从上面的锁模式相容性矩阵可以看出，AccessShareLock、RowShareLock、RowExclusiveLock这三个锁模式是互不冲突的，而且常用于DML操作，因此成为弱锁，剩余5个锁则为强锁。弱锁之间互不冲突，强锁和弱锁冲突。
• 本地锁表：保存在当前进程中，对重复申请的锁进行计数，相当与本地缓存，避免重复访问主锁表和进程锁表。

所以申请锁时从上述4个位置查找的流程为：本地锁表–>快速路径–>进程锁表=主锁表，有三个全局变量控制，是哈希表

static HTAB *LockMethodLockHash;//本地锁表
static HTAB *LockMethodProcLockHash;//进程锁表
static HTAB *LockMethodLocalHash;//主锁表

结构体

锁相关的结构体主要就是上述几种类型，如下图

Lock

Lock结构体记录了主锁表中锁对象的所有相关信息，比如当前持有锁的信息，等待锁的信息，关联的进程等信息。

typedef enum LockTagType
{
LOCKTAG_RELATION,/* 表锁 */
LOCKTAG_RELATION_EXTEND,/* 对表进行扩展时加的锁*/
LOCKTAG_DATABASE_FROZEN_IDS,/* 数据库冻结ID时的锁 */
LOCKTAG_PAGE,/* 页锁 */
LOCKTAG_TUPLE,/* 行锁 */
LOCKTAG_TRANSACTION,/* 事务锁*/
LOCKTAG_VIRTUALTRANSACTION, /* 虚拟事务锁 */
LOCKTAG_SPECULATIVE_TOKEN,/* UPSERT语句中需要等待confirm的元组加锁*/
LOCKTAG_OBJECT,/* 非表对象锁*/
LOCKTAG_USERLOCK,/* 用户锁 */
LOCKTAG_ADVISORY/* 咨询锁*/
} LockTagType;

typedef struct LOCKTAG
{
uint32locktag_field1; /*  dboid */
uint32locktag_field2; /*  reloid */
uint32locktag_field3; /*  blocknum */
uint16locktag_field4; /*  forknum */
uint8locktag_type;/* 锁类型，参见LockTagType类型 */
uint8locktag_lockmethodid;/* lockmethod indicator： 锁方法，目前就两种：默认锁方法和用户锁方法 */
} LOCKTAG;

typedef struct LOCK
{
/* hash key */
LOCKTAGtag;/* 标识符，全局唯一*/

/* data */
LOCKMASKgrantMask;/* 已经被持有的锁的掩码 */
LOCKMASKwaitMask;/* 正在等待的锁的掩码 */
SHM_QUEUEprocLocks;/* 当前锁相关联的进程锁表 */
PROC_QUEUEwaitProcs;/* 正在等待当前锁的进程锁表 */
int requested[MAX_LOCKMODES];/* 需要当前锁的会话的数量 */
int nRequested;/* 需索当前锁的所有会话数量 */
int granted[MAX_LOCKMODES]; /* 已经持有当前锁的会话数 */
int nGranted;/* 已经持有当前锁的所有会话的数量 */
} LOCK;

LocalLock

本地锁表就是锁对象在本地进程的缓存，进程第一次申请一个锁对象后会将其放到本地锁表中，后面若是需要再申请该锁，则直接从本地锁表中获取即可，不需要再去主锁表申请，能大大提升性能。

typedef struct LOCALLOCKTAG
{
LOCKTAGlock;/* 本地锁表的标识符*/
LOCKMODEmode;/* 表的锁模式 */
} LOCALLOCKTAG;

//本地锁表类型
typedef struct LOCALLOCK
{
/* tag */
LOCALLOCKTAG tag;/* 锁标识符：  */
/* data */
uint32hashcode;/* 锁标识符的哈希值： */
LOCK   *lock;/* 锁对象：*/
PROCLOCK   *proclock;/* 进程锁表对象 */
int64nLocks;/* 锁被持有的最大次数 */
intnumLockOwners;/* 相关的resourceOwner数量： */
intmaxLockOwners;/* 分匹配的数组大小 */
LOCALLOCKOWNER *lockOwners; /* 动态再分配*/
boolholdsStrongLockCount;/* 是否持有强锁 */
boollockCleared;/* 锁是否已清理 */
} LOCALLOCK;

ProcLock

PROCLOCK结构记录进程锁表所有相关信息，它是锁对象与进程连接的纽带，这样就能通过Lock锁对象查找申请该锁对应的进程信息，也能通过Proc进程对象查找其申请的锁的信息。

typedef struct PROCLOCKTAG
{
/* NB: we assume this struct contains no padding! */
LOCK   *myLock;/* 关联的锁的信息 */
PGPROC   *myProc;/* 关联的进程的信息 */
} PROCLOCKTAG;

//进程锁表，每个需求锁的信息
typedef struct PROCLOCK
{
/* tag */
PROCLOCKTAG tag;/* 进程锁表标识，全局唯一 */

/* data */
PGPROC   *groupLeader;/* 每个锁组的组长信息 */
LOCKMASKholdMask;/* 当前持有锁的类型的掩码信息*/
LOCKMASKreleaseMask;/* 要释放的锁类型的掩码 */
SHM_QUEUElockLink;/* 进程锁表的锁链表*/
SHM_QUEUEprocLink;/* 进程锁表的进程链表*/
} PROCLOCK;

相关函数

LockAcquireExtended

该函数的作用就是申请一把常规锁。其申请流程就是判断申请的锁的位置，然后申请，先尝试从本地锁表中申请，然后尝试从快速路径中申请，最后是从主锁表和进程锁表申请。

从本地锁表申请

本地锁表是由一个全局变量LockMethodLocalHash记录，这是一个哈希表，申请本地锁表会根据申请的锁的类型和信息从LockMethodLocalHash中进行查找，并返回查找结果。
如果找到则增加锁计数后直接返回申请结果。如果本地锁表已经没有空间保存申请的锁的LockOwner信息，则扩容一倍。
如果没有找到，初始化一个空的本地锁表结构，后面在其他位置申请到后直接保存到本地锁表中。

    //去本地锁表查询，是一个哈希表，找到的话，返回找到的本地锁对象
locallock = (LOCALLOCK *) hash_search(LockMethodLocalHash,
  (void *) &localtag,
  HASH_ENTER, &found);
if (!found)//没有找到，先本地初始化一个空的本地锁表对象，后面从其他地方找到后会先放入本地锁表中
{
locallock->lock = NULL;
locallock->proclock = NULL;
locallock->hashcode = LockTagHashCode(&(localtag.lock));
locallock->nLocks = 0;
locallock->holdsStrongLockCount = false;
locallock->lockCleared = false;
locallock->numLockOwners = 0;
locallock->maxLockOwners = 8;
locallock->lockOwners = NULL;
locallock->lockOwners = (LOCALLOCKOWNER *)
MemoryContextAlloc(TopMemoryContext,
   locallock->maxLockOwners * sizeof(LOCALLOCKOWNER));
}
else//本地锁表找到了
{
if (locallock->numLockOwners >= locallock->maxLockOwners)//如果持有该锁的用户大于限制数量，再扩大一倍
{
intnewsize = locallock->maxLockOwners * 2;

locallock->lockOwners = (LOCALLOCKOWNER *)
repalloc(locallock->lockOwners,
 newsize * sizeof(LOCALLOCKOWNER));
locallock->maxLockOwners = newsize;
}
}
hashcode = locallock->hashcode;

if (locallockp)
*locallockp = locallock;//保存找到的本地锁
if (locallock->nLocks > 0)
{
GrantLockLocal(locallock, owner);//增加锁计数
if (locallock->lockCleared) //返回结果
return LOCKACQUIRE_ALREADY_CLEAR;
else
return LOCKACQUIRE_ALREADY_HELD;
}  

从快速路径申请

从快速路径申请，分为申请弱锁和强锁。
本地进程最多保存16把弱锁，这是因为本地进程PGPROC->fpRelId是一个长度为16的数组，它里面保存的是本地进程只有锁的表的OID信息，这就限制了弱锁的数量。

• 申请弱锁
  • 判断是否为弱锁，其判断条件为：
    1. 锁类型是表锁，锁模式<4，即前三种锁，通过EligibleForRelationFastPath宏判断

       #define EligibleForRelationFastPath(locktag, mode) \
    

  ((locktag)->locktag_lockmethodid == DEFAULT_LOCKMETHOD &&
  (locktag)->locktag_type == LOCKTAG_RELATION &&
  (locktag)->locktag_field1 == MyDatabaseId &&
  MyDatabaseId != InvalidOid &&
  (mode) < ShareUpdateExclusiveLock)
  ```
  2. 本地保存的快速路径锁数量小于16
  • 获取强锁的哈希码
  • 判断强锁是否存在，根据全局变量FastPathStrongRelationLocks来判断，如果存在，则申请失败
  • 如果强锁不存在，则申请弱锁
  • 申请到弱锁，更新锁计数并返回

if (EligibleForRelationFastPath(locktag, lockmode) &&
FastPathLocalUseCount < FP_LOCK_SLOTS_PER_BACKEND)//判断是否为弱锁：最大可持有16个 
{
uint32fasthashcode = FastPathStrongLockHashPartition(hashcode);//获取强锁的哈希码
boolacquired;
LWLockAcquire(&MyProc->fpInfoLock, LW_EXCLUSIVE);
if (FastPathStrongRelationLocks->count[fasthashcode] != 0)//判断该强锁是否已存在，若已存在则申请失败
acquired = false;
else
acquired = FastPathGrantRelationLock(locktag->locktag_field2,
 lockmode);//申请弱锁
LWLockRelease(&MyProc->fpInfoLock);
if (acquired)//申请到弱锁，直接返回
{
locallock->lock = NULL;
locallock->proclock = NULL;
GrantLockLocal(locallock, owner);//增加锁计数
return LOCKACQUIRE_OK;
}
}     

• 申请强锁
  • 判断是否为强锁
    判断锁模式等信息，根据ConflictsWithRelationFastPath宏判断

#define ConflictsWithRelationFastPath(locktag, mode) \
((locktag)->locktag_lockmethodid == DEFAULT_LOCKMETHOD && \
(locktag)->locktag_type == LOCKTAG_RELATION && \
(locktag)->locktag_field1 != InvalidOid && \
(mode) > ShareUpdateExclusiveLock)//判断是否为强锁

- 获取强锁哈希码
- 申请强锁
- 如果申请到强锁，则将其他进程保存的该锁的弱锁转移到主锁表中

if (ConflictsWithRelationFastPath(locktag, lockmode))
{
uint32fasthashcode = FastPathStrongLockHashPartition(hashcode);//获取哈希码
BeginStrongLockAcquire(locallock, fasthashcode);//申请强锁
//将其他事务保存的弱锁保存到主锁表中，因为有了强锁之后，强锁与弱锁就冲突了
if (!FastPathTransferRelationLocks(lockMethodTable, locktag,
   hashcode))
{
AbortStrongLockAcquire();//终止获取强锁
if (locallock->nLocks == 0)
RemoveLocalLock(locallock); //如果引用计数为0，就删除本地锁
else
return LOCKACQUIRE_NOT_AVAIL;
}
}

从主锁表申请

如果本地锁表和快速路径都没申请到锁，则需要去主锁表中申请了，调用SetupLockInTable函数申请，申请到之后，还需要进行锁冲突检测，如果没有冲突，就可以直接获取这个锁了，但是如果有锁冲突，就需要将自己放到等待队列上等待了。主要流程如下：

• 先申请主锁表的轻量锁MainLWLockArray，因为要访问共享内存，以排他模式申请

partitionLock = LockHashPartitionLock(hashcode);
LWLockAcquire(partitionLock, LW_EXCLUSIVE);

• 调用SetupLockInTable函数申请，该函数会先去主锁表和进程锁表中查找要申请的锁，如果没有找到，则需要申请内存来保存申请的锁的信息。

proclock = SetupLockInTable(lockMethodTable, MyProc, locktag,hashcode, lockmode);//去主锁表中寻找
if (!proclock)
return LOCKACQUIRE_NOT_AVAIL;

• 将申请到锁保存到本地锁表中，下一次再申请就可以直接从本地锁表中申请了

locallock->proclock = proclock;
lock = proclock->tag.myLock;
locallock->lock = lock;

• 检查锁是否与其他锁冲突，如果没有冲突更新锁计数

if (lockMethodTable->conflictTab[lockmode] & lock->waitMask)
found_conflict = true;
else
found_conflict = LockCheckConflicts(lockMethodTable, lockmode,lock, proclock);

if (!found_conflict)
{
GrantLock(lock, proclock, lockmode);
GrantLockLocal(locallock, owner);

• 如果锁冲突，但不需要等待，则删除当前记录的锁信息，直接返回获取失败，是否需要等待由传入的参数dontWait确定

if (dontWait)
{
AbortStrongLockAcquire();
if (proclock->holdMask == 0)
{
uint32proclock_hashcode;
proclock_hashcode = ProcLockHashCode(&proclock->tag, hashcode);
SHMQueueDelete(&proclock->lockLink);
SHMQueueDelete(&proclock->procLink);
}
lock->nRequested--;
lock->requested[lockmode]--;
LOCK_PRINT("LockAcquire: conditional lock failed", lock, lockmode);
Assert((lock->nRequested > 0) && (lock->requested[lockmode] >= 0));
Assert(lock->nGranted <= lock->nRequested);
LWLockRelease(partitionLock);
if (locallock->nLocks == 0)
RemoveLocalLock(locallock);
if (locallockp)
*locallockp = NULL;
return LOCKACQUIRE_NOT_AVAIL;
}

• 如果锁冲突，且需要等待，调用WaitOnLock函数等待锁的释放。

MyProc->heldLocks = proclock->holdMask;
WaitOnLock(locallock, owner);//不能获取到锁，进入等待队列等待

• 释放MainLWLockArray锁

LWLockRelease(partitionLock);

SetupLockInTable

从主锁表和进程锁表中查找一个锁对象，如果找不到就创建一个新的。

• 查询主锁表，从全局变量LockMethodLockHash中查询

lock = (LOCK *) hash_search_with_hash_value(LockMethodLockHash,(const void *) locktag,hashcode,HASH_ENTER_NULL,&found);

• 没查到，创建新的锁对象

if (!found)//没有找到，创建一个新的锁对象
{
lock->grantMask = 0;
lock->waitMask = 0;
SHMQueueInit(&(lock->procLocks));
ProcQueueInit(&(lock->waitProcs));
lock->nRequested = 0;
lock->nGranted = 0;
MemSet(lock->requested, 0, sizeof(int) * MAX_LOCKMODES);
MemSet(lock->granted, 0, sizeof(int) * MAX_LOCKMODES);
LOCK_PRINT("LockAcquire: new", lock, lockmode);

• 查询进程锁表，从全局变量LockMethodProcLockHash中查询

proclocktag.myLock = lock;//获取进程锁表的tag信息
proclocktag.myProc = proc;

proclock_hashcode = ProcLockHashCode(&proclocktag, hashcode);
proclock = (PROCLOCK *) hash_search_with_hash_value(LockMethodProcLockHash,(void *) &proclocktag,proclock_hashcode,HASH_ENTER_NULL,&found);

• 没查到，创建新的进程锁表对象

if (!found)//如果没找到就是创建一个新的进程锁表
{
uint32partition = LockHashPartition(hashcode);
proclock->groupLeader = proc->lockGroupLeader != NULL ?proc->lockGroupLeader : proc;
proclock->holdMask = 0;
proclock->releaseMask = 0;
SHMQueueInsertBefore(&lock->procLocks, &proclock->lockLink);
SHMQueueInsertBefore(&(proc->myProcLocks[partition]),
 &proclock->procLink);
PROCLOCK_PRINT("LockAcquire: new", proclock);
}

LockCheckConflicts

检查当前要申请的锁是否与其他的进程持有的锁冲突，主要通过主锁表中的conflicttab的掩码值与要申请的锁的掩码进行比较得出结果。如果存在多进程的情况（即group），还需要排除掉同group的冲突锁，最终得出是否冲突的结果。

• 判断要申请的锁是否与主锁表中的其他锁冲突，没有冲突直接返回

if (!(conflictMask & lock->grantMask))//判断当前锁模式掩码与冲突的掩码。得出是否存在冲突
{
PROCLOCK_PRINT("LockCheckConflicts: no conflict", proclock);
return false;//都不冲突
}

• 如果存在冲突，遍历所有的锁模式，判断冲突的锁进程的数量，去掉当前进程，如果数量为0，表示为没有冲突

myLocks = proclock->holdMask;
for (i = 1; i <= numLockModes; i++)//遍历所有锁模式
{
if ((conflictMask & LOCKBIT_ON(i)) == 0)//指定的锁模式上不存在冲突
{
conflictsRemaining[i] = 0;
continue;
}
conflictsRemaining[i] = lock->granted[i];//第i个模式在Lock上被授予了多少次了
if (myLocks & LOCKBIT_ON(i))
--conflictsRemaining[i];//是当前进程持有的锁，不算冲突
totalConflictsRemaining += conflictsRemaining[i];//统计有多少个事务持有该锁，不包括自己
}

/* If no conflicts remain, we get the lock. */
if (totalConflictsRemaining == 0)//没有冲突的锁，那么可以直接获取该锁
{
PROCLOCK_PRINT("LockCheckConflicts: resolved (simple)", proclock);
return false;
}

• 如果数量不为0，且没有group，那么存在冲突

//如果有冲突的锁，且Groupleader是自己即单进程，则有冲突
if (proclock->groupLeader == MyProc && MyProc->lockGroupLeader == NULL)
{
Assert(proclock->tag.myProc == MyProc);
PROCLOCK_PRINT("LockCheckConflicts: conflicting (simple)",
   proclock);
return true;
}

• 如果存在group，则遍历每个进程，减去与当前进程同一个group的进程，得到剩余的总数量，如果为0，不存在冲突，否则存在冲突

procLocks = &(lock->procLocks);
otherproclock = (PROCLOCK *)
SHMQueueNext(procLocks, procLocks, offsetof(PROCLOCK, lockLink));
//遍历所有其他的进程，减去与当前进程一个group的冲突的锁，减完如果为0就没有冲突，否则就有冲突
while (otherproclock != NULL)
{
if (proclock != otherproclock &&
proclock->groupLeader == otherproclock->groupLeader &&
(otherproclock->holdMask & conflictMask) != 0)//其他的进程且与当前进程在一个group中，且存在锁冲突
{
intintersectMask = otherproclock->holdMask & conflictMask;//是否冲突

for (i = 1; i <= numLockModes; i++)//遍历所有锁模式
{
if ((intersectMask & LOCKBIT_ON(i)) != 0)//冲突
{
conflictsRemaining[i]--;//因为是同组的，所以冲突的就不是冲突了，减掉
totalConflictsRemaining--;
}
}

if (totalConflictsRemaining == 0)//所有冲突的锁都符合，那么就不存在锁冲突了
{
PROCLOCK_PRINT("LockCheckConflicts: resolved (group)",proclock);
return false;
}
}
otherproclock = (PROCLOCK *)
SHMQueueNext(procLocks, &otherproclock->lockLink,
 offsetof(PROCLOCK, lockLink));//遍历下一个
}

FastPathGrantRelationLock

申请快速路径的弱锁，每个进程最多能持有16个弱锁，所以预留的槽位只有16个，遍历 每个槽位，找到没被占用的槽位，然后将要申请的锁信息填入该槽位占住即可。

static bool
FastPathGrantRelationLock(Oid relid, LOCKMODE lockmode)
{
uint32f;
uint32unused_slot = FP_LOCK_SLOTS_PER_BACKEND;

/* Scan for existing entry for this relid, remembering empty slot. */
for (f = 0; f < FP_LOCK_SLOTS_PER_BACKEND; f++)//遍历每一个槽位，通16个槽位
{
if (FAST_PATH_GET_BITS(MyProc, f) == 0)//判断是否还未被占用
unused_slot = f;
else if (MyProc->fpRelId[f] == relid)//判断当前表是否已经申请过
{
Assert(!FAST_PATH_CHECK_LOCKMODE(MyProc, f, lockmode));
FAST_PATH_SET_LOCKMODE(MyProc, f, lockmode);
return true;
}
}

/* If no existing entry, use any empty slot. */
if (unused_slot < FP_LOCK_SLOTS_PER_BACKEND)
{
MyProc->fpRelId[unused_slot] = relid;//占用空闲的槽位
FAST_PATH_SET_LOCKMODE(MyProc, unused_slot, lockmode);//更新锁标记
++FastPathLocalUseCount;//更新快速路径计数
return true;
}

/* No existing entry, and no empty slot. */
return false;
}

BeginStrongLockAcquire

申请强锁，就是更新全局变量FastPathStrongRelationLocks的值，然后将本地锁表的holdsStrongLockCount设置为true

BeginStrongLockAcquire(LOCALLOCK *locallock, uint32 fasthashcode)
{
SpinLockAcquire(&FastPathStrongRelationLocks->mutex);//修改全局变量，先申请锁
FastPathStrongRelationLocks->count[fasthashcode]++;//更新对应的强锁计数
locallock->holdsStrongLockCount = true;//标记一下，本地锁表申请的有强锁
StrongLockInProgress = locallock;//当前的锁是强锁
SpinLockRelease(&FastPathStrongRelationLocks->mutex);//释放锁
}

FastPathTransferRelationLocks

获取到强锁以后，如果其他进程的快速路径上还保存有对应的弱锁，就需要将这些弱锁挪到主锁表中，否则这些快速路径上的弱锁将因为与强锁冲突而失效。
该函数会遍历所有的进程，所有的进程保存在全局变量ProcGlobal->allProcs中，然后查找对应的弱锁，找到后挪到主锁表中,主要流程如下：

• 遍历每个进程，如果跟持锁的数据库信息不一致，直接跳过
• 遍历每个进程上的弱锁的槽位（16个），弱锁相关的表ID跟申请的不一致或对应槽位未被使用，直接跳过
• 遍历每个弱锁模式（3个），若该模式弱锁不存在，直接跳过
• 走到这里，就说明该进程的某个槽位存在弱锁且与申请的强锁冲突，去主锁表中重新创建该锁（即将该弱锁转移到主锁表中）。
• 清空该进程上相关的弱锁信息

FastPathTransferRelationLocks(LockMethod lockMethodTable, const LOCKTAG *locktag,
  uint32 hashcode)
{
LWLock   *partitionLock = LockHashPartitionLock(hashcode);
Oidrelid = locktag->locktag_field2;
uint32i;
for (i = 0; i < ProcGlobal->allProcCount; i++)//遍历所有的进程
{
PGPROC   *proc = &ProcGlobal->allProcs[i];//取一个进程
uint32f;

LWLockAcquire(&proc->fpInfoLock, LW_EXCLUSIVE);//获取该进程上的快速路径锁，锁住后禁止其他进程访问该进程相关的快速路径的信息

if (proc->databaseId != locktag->locktag_field1)//如果不然会同一个数据库，可以直接跳过，因为不相关
{
LWLockRelease(&proc->fpInfoLock);
continue;
}

for (f = 0; f < FP_LOCK_SLOTS_PER_BACKEND; f++)//遍历进程上的所有弱锁槽位
{
uint32lockmode;

/* Look for an allocated slot matching the given relid. */
if (relid != proc->fpRelId[f] || FAST_PATH_GET_BITS(proc, f) == 0)//表ID或持锁信息不符合要求，跳过
continue;

/* Find or create lock object. */
LWLockAcquire(partitionLock, LW_EXCLUSIVE);//主锁表加锁
for (lockmode = FAST_PATH_LOCKNUMBER_OFFSET;
 lockmode < FAST_PATH_LOCKNUMBER_OFFSET + FAST_PATH_BITS_PER_SLOT;
 ++lockmode)//遍历每种弱锁模式
{
PROCLOCK   *proclock;

if (!FAST_PATH_CHECK_LOCKMODE(proc, f, lockmode))//不存在弱锁，跳过
continue;
proclock = SetupLockInTable(lockMethodTable, proc, locktag,
hashcode, lockmode);//在主锁表中创建或申请对应的锁
if (!proclock)
{
LWLockRelease(partitionLock);
LWLockRelease(&proc->fpInfoLock);
return false;
}
GrantLock(proclock->tag.myLock, proclock, lockmode);//更新锁计数
FAST_PATH_CLEAR_LOCKMODE(proc, f, lockmode);//清空该进程上的弱锁计数
}
LWLockRelease(partitionLock);

/* No need to examine remaining slots. */
break;
}
LWLockRelease(&proc->fpInfoLock);
}
return true;
}

WaitOnLock

当前进程睡眠并等待其期望的锁释放，调用ProcSleep函数睡眠，ProcSleep函数中又会调用CheckDeadLock函数进行死锁检测。

【参考】

1. 《PostgreSQL数据库内核分析》
2. 《Postgresql技术内幕-事务处理深度探索》
3. 《PostgreSQL指南：内幕探索》
4. pg14源码

原文地址：https://blog.csdn.net/mirai_D_zoro/article/details/142532818

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