postgresql regular lock常规锁烤的内嫩外焦，入口即化-Toy模板网

这篇具有很好参考价值的文章主要介绍了postgresql regular lock常规锁烤的内嫩外焦，入口即化。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

postgresql regular lock常规锁烤的内嫩外焦，入口即化,# postgresql内核源码分析,postgresql,postgresql,数据库,sql,c语言,linux,数据库架构,架构

专栏内容：
postgresql内核源码分析
手写数据库toadb
并发编程
个人主页：我的主页
座右铭：天行健，君子以自强不息；地势坤，君子以厚德载物.

==================================

介绍

常规锁，主要用于数据库对象的加锁，如表，根据用户请求来加锁。

它有死锁检测，在事务结束时会自动释放。

regular lock原理

regular lock像lwlock一样会预先在共享内存中分配，对于每一类型需要加锁的数据库对象都会分配一个锁对象。

为了标识具体的数据库对象，所以locktag唯一标识了每个锁，它的内容与加锁对象关联起来。这里就有个问题，数据库对象可以非常多，锁的数量也很庞大，如何确定锁的数量呢？

regular lock 结构

typedef struct LOCK
{
	/* hash key */
	LOCKTAG		tag;			/* unique identifier of lockable object */

	/* data */
	LOCKMASK	grantMask;		/* bitmask for lock types already granted */
	LOCKMASK	waitMask;		/* bitmask for lock types awaited */
	dlist_head	procLocks;		/* list of PROCLOCK objects assoc. with lock */
	dclist_head waitProcs;		/* list of PGPROC objects waiting on lock */
	int			requested[MAX_LOCKMODES];	/* counts of requested locks */
	int			nRequested;		/* total of requested[] array */
	int			granted[MAX_LOCKMODES]; /* counts of granted locks */
	int			nGranted;		/* total of granted[] array */
} LOCK;

锁标识 LOCKTAG

锁标识的定义如下

typedef struct LOCKTAG
{
	uint32		locktag_field1; /* a 32-bit ID field */
	uint32		locktag_field2; /* a 32-bit ID field */
	uint32		locktag_field3; /* a 32-bit ID field */
	uint16		locktag_field4; /* a 16-bit ID field */
	uint8		locktag_type;	/* see enum LockTagType */
	uint8		locktag_lockmethodid;	/* lockmethod indicator */
} LOCKTAG;

locktag 唯一标识一个常规锁，它由6个成员组成，前四个成员，在不同类型的锁中对应不同的数据

最后一个lockmethodid是定义锁的操作及冲突矩阵，一般采用默认的定义

LOCKTAG_RELATION	LOCKTAG
LOCKTAG_RELATION	locktag_field1 = dboid 当relation 为共享表时 dboid = 0 locktag_field2 = reloid
LOCKTAG_RELATION_EXTEND	同上
LOCKTAG_DATABASE_FROZEN_IDS	locktag_field1 = dboid
LOCKTAG_PAGE	locktag_field1 = dboid locktag_field2 = reloid locktag_field3 = blocknum
LOCKTAG_TUPLE	locktag_field1 = dboid locktag_field2 = reloid locktag_field3 = blocknum locktag_field4 = offnum
LOCKTAG_TRANSACTION	locktag_field1 = xid locktag_field2 = 0 locktag_field3 = 0 locktag_field4 = 0
LOCKTAG_VIRTUALTRANSACTION	locktag_field1 = (vxid).backendId locktag_field2 = (vxid).localTransactionId locktag_field3 = 0 locktag_field4 = 0
LOCKTAG_SPECULATIVE_TOKEN	locktag_field1 = xid locktag_field2 = token locktag_field3 = 0 locktag_field4 = 0
LOCKTAG_OBJECT	locktag_field1 = dboid locktag_field2 = classoid locktag_field3 = objoid locktag_field4 = objsubid
LOCKTAG_USERLOCK	用户自定义锁
LOCKTAG_ADVISORY	locktag_field1 = id1 locktag_field2 = id2 locktag_field3 = id3 locktag_field4 = id4
LOCKTAG_APPLY_TRANSACTION	locktag_field1 = dboid locktag_field2 = suboid locktag_field3 = xid locktag_field4 = objid

锁流程

初始化

初始化主要获取锁的共享内存区域指针，并且创建本地记录已持有锁的hash空间。
另外还有一个全局hash记录锁持有者，在共享内存中存储。

锁的初始化接口如下

void InitLocks(void);

获取锁的数量

  #define NLOCKENTS() \
	mul_size(max_locks_per_xact, add_size(MaxBackends, max_prepared_xacts))

  max_table_size = NLOCKENTS();
  init_table_size = max_table_size / 2;

每个backend可以最大持有锁的数量由GUC参数决定，最小10，最大为int上限

在共享内存中分配锁的内存空间

  LockMethodLockHash = ShmemInitHash("LOCK hash",
									   init_table_size,
									   max_table_size,
									   &info,
									   HASH_ELEM | HASH_BLOBS | HASH_PARTITION);

常规锁在hash中存储，LockMethodLockHash的大小分配初始大小，不够时会再扩展，直到最大值。

锁持有者记录的内存空间

锁持有者，按每个锁平均有两个持有者来计算，所以空间大小为

	max_table_size *= 2;
	init_table_size *= 2;

也是用hash链表来记录，在共享内存中分配

	LockMethodProcLockHash = ShmemInitHash("PROCLOCK hash",
										   init_table_size,
										   max_table_size,
										   &info,
										   HASH_ELEM | HASH_FUNCTION | HASH_PARTITION);

fastpath 信息记录的内存空间分配

	FastPathStrongRelationLocks =
		ShmemInitStruct("Fast Path Strong Relation Lock Data",
						sizeof(FastPathStrongRelationLockData), &found);

每个backend自己也会记录自己持有锁信息

	LockMethodLocalHash = hash_create("LOCALLOCK hash",
									  16,
									  &info,
									  HASH_ELEM | HASH_BLOBS);

这里也是使用hash，内存是在当前本地内存分配，大小指定为16，这里对于重复持有锁只累积计数。

锁种类

typedef enum LockTagType
{
	LOCKTAG_RELATION,			/* whole relation */
	LOCKTAG_RELATION_EXTEND,	/* the right to extend a relation */
	LOCKTAG_DATABASE_FROZEN_IDS,	/* pg_database.datfrozenxid */
	LOCKTAG_PAGE,				/* one page of a relation */
	LOCKTAG_TUPLE,				/* one physical tuple */
	LOCKTAG_TRANSACTION,		/* transaction (for waiting for xact done) */
	LOCKTAG_VIRTUALTRANSACTION, /* virtual transaction (ditto) */
	LOCKTAG_SPECULATIVE_TOKEN,	/* speculative insertion Xid and token */
	LOCKTAG_OBJECT,				/* non-relation database object */
	LOCKTAG_USERLOCK,			/* reserved for old contrib/userlock code */
	LOCKTAG_ADVISORY,			/* advisory user locks */
	LOCKTAG_APPLY_TRANSACTION	/* transaction being applied on a logical
								 * replication subscriber */
} LockTagType;

当前使用regular lock 加锁的数据库对象，由LockTagType定义，每一种对象都有对应的加锁、解锁接口

常规锁接口

表锁相关接口

表锁被分为8级，每级定义了使用范围，同时按等级递增规定了冲突矩阵。

在open表时，使用OID或relid来对表进行加锁，也可以尝试加锁，不进行等待

extern void LockRelationOid(Oid relid, LOCKMODE lockmode);
extern void LockRelationId(LockRelId *relid, LOCKMODE lockmode);
extern bool ConditionalLockRelationOid(Oid relid, LOCKMODE lockmode);
extern void UnlockRelationId(LockRelId *relid, LOCKMODE lockmode);
extern void UnlockRelationOid(Oid relid, LOCKMODE lockmode);

以下接口是open之后，进一步对表加锁时调用

此时relation结构可用，直接使用此结构就可以对表加锁

extern void LockRelation(Relation relation, LOCKMODE lockmode);
extern bool ConditionalLockRelation(Relation relation, LOCKMODE lockmode);
extern void UnlockRelation(Relation relation, LOCKMODE lockmode);
extern bool CheckRelationLockedByMe(Relation relation, LOCKMODE lockmode,
									bool orstronger);
extern bool LockHasWaitersRelation(Relation relation, LOCKMODE lockmode);

extern void LockRelationIdForSession(LockRelId *relid, LOCKMODE lockmode);
extern void UnlockRelationIdForSession(LockRelId *relid, LOCKMODE lockmode);

表扩展时相关锁接口

extern void LockRelationForExtension(Relation relation, LOCKMODE lockmode);
extern void UnlockRelationForExtension(Relation relation, LOCKMODE lockmode);
extern bool ConditionalLockRelationForExtension(Relation relation,
												LOCKMODE lockmode);
extern int	RelationExtensionLockWaiterCount(Relation relation);

计算database frozenxid时的锁接口

extern void LockDatabaseFrozenIds(LOCKMODE lockmode);

每个数据库会计算 frozenxid，然后计算所有库的最小值作为集群的frozenxid;
每个database的值在 pg_database.datfrozenxid 字段中存储

锁定page 时的接口

extern void LockPage(Relation relation, BlockNumber blkno, LOCKMODE lockmode);
extern bool ConditionalLockPage(Relation relation, BlockNumber blkno, LOCKMODE lockmode);
extern void UnlockPage(Relation relation, BlockNumber blkno, LOCKMODE lockmode);

当前只在索引中使用

行锁接口

extern void LockTuple(Relation relation, ItemPointer tid, LOCKMODE lockmode);
extern bool ConditionalLockTuple(Relation relation, ItemPointer tid,
								 LOCKMODE lockmode);
extern void UnlockTuple(Relation relation, ItemPointer tid, LOCKMODE lockmode);

事务等待锁接口

extern void XactLockTableInsert(TransactionId xid);
extern void XactLockTableDelete(TransactionId xid);
extern void XactLockTableWait(TransactionId xid, Relation rel,
							  ItemPointer ctid, XLTW_Oper oper);
extern bool ConditionalXactLockTableWait(TransactionId xid);

主要用于事务隔离冲突时，等待某个事务xid结束时使用

VXID锁接口

extern void WaitForLockers(LOCKTAG heaplocktag, LOCKMODE lockmode, bool progress);
extern void WaitForLockersMultiple(List *locktags, LOCKMODE lockmode, bool progress);

用于 VXID冲突时进行等待

行插入锁接口

extern uint32 SpeculativeInsertionLockAcquire(TransactionId xid);
extern void SpeculativeInsertionLockRelease(TransactionId xid);
extern void SpeculativeInsertionWait(TransactionId xid, uint32 token);

其它数据库对象（除表外）

extern void LockDatabaseObject(Oid classid, Oid objid, uint16 objsubid,
							   LOCKMODE lockmode);
extern void UnlockDatabaseObject(Oid classid, Oid objid, uint16 objsubid,
								 LOCKMODE lockmode);

跨库数据库对角

extern void LockSharedObject(Oid classid, Oid objid, uint16 objsubid,
							 LOCKMODE lockmode);
extern void UnlockSharedObject(Oid classid, Oid objid, uint16 objsubid,
							   LOCKMODE lockmode);

extern void LockSharedObjectForSession(Oid classid, Oid objid, uint16 objsubid,
									   LOCKMODE lockmode);
extern void UnlockSharedObjectForSession(Oid classid, Oid objid, uint16 objsubid,
										 LOCKMODE lockmode);

extern void LockApplyTransactionForSession(Oid suboid, TransactionId xid, uint16 objid,
										   LOCKMODE lockmode);
extern void UnlockApplyTransactionForSession(Oid suboid, TransactionId xid, uint16 objid,
											 LOCKMODE lockmode);