pg内核之事务管理器（三） 两阶段提交

最新推荐文章于 2024-04-25 07:46:25 发布
最新推荐文章于 2024-04-25 07:46:25 发布
阅读量1k 收藏 17
点赞数 26
分类专栏： pg 文章标签： postgresql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mirai_D_zoro/article/details/135296423
版权

#pg内核 #事务

概述

两阶段提交主要用于分布式数据库中，分布式数据库本质上是将数据分布到不同的主机上，以实现大数据量的存储。例如greenplum数据库就是基于pg的分布式分析型数据库。分布式数据库主要有两个关注点：分布式执行计划，分布式事务。而分布式事务就是本章要将的两阶段提交。
两阶段提交主要解决两个难点：

  • 读操作需要保证在不同的主机上读到一致的数据。
  • 需要保证事务在不同主机上的原子性，不能出现某个主机上写数据成功，另一个主机上写数据失败的情况。

两阶段提交就是针对写操作，将事务的提交分为两个阶段，当数据写入不同的主机时，要么全部提交，要么全部回滚。
两阶段提交遵循XA协议，XA协议是一种分布式事务协议，由Tuxedo提出。XA中主要可以分为两部分：事务管理器和本地资源管理器。 其中本地资源管理器由本地数据库实现，事务管理器作为全局的调度者，负责各个本地资源的提交和回滚。

  • 2PC： 两阶段提交，是XA协议用于在全局事务中协调多个资源的机制，遵循OSI/DTP 标准。包含两个阶段：准备阶段和提交阶段
  • 3PC： 三阶段提交，是两阶段提交的改进版，包含三个阶段：canCommit阶段、PreCommit阶段和DoCommit阶段。相比于两阶段提交，它的改进点是：
    1. 同时在协调者和参与者中引入超时机制
    2. 引入了一个准备阶段，保证最后提交阶段之前各参与节点的状态是一致的。

pg中是通过max_prepared_transactions参数来控制两阶段提交，当为0时关闭两阶段提交，非0时打开两阶段提交。
正常的事务，在事务commit之前，事务的数据时不会落盘的，一旦这时数据库异常或事务异常，数据将会丢失，但是两阶段提交执行后，即使没有提交，事务相关数据也会刷入磁盘，这时候即使重启了数据库，之前2PC执行的相关事务数据仍然存在。

2PC的使用示例

  • 打开2PC的开关
    配置max_prepared_transactions为非0值，如100
  • 执行2PC SQL命令
CREATE TABLE tb1(id int);
BEGIN;
PREPARE TRANSACTION 'P1';  --创建两阶段提交事务
INSERT INTO tb1 VALUES(1); --插入一行数据
SELECT * FROM tb1;  --查询表的内容
SELECT * FROM pg_prepared_xacts; --查询两阶段提交事务内容
  • 重启数据库
  • 查看2PC并提交
SELECT * FROM pg_prepared_xacts; --查询两阶段提交事务内容 
COMMIT PREPARED 'P1'; --提交两阶段提交事务
  • 回滚2PC
ROLLBACK PREPARED 'P1';

2PC执行流程

2PC的执行流程主要分为两个阶段： PREPARE阶段，COMMIT/ROLLBACK阶段
引入一个协调者coordinator来协调各个数据库的准备和提交，有了解greenplum数据库的应该就知道，greenplum中的master其实就是扮演者coordinator的角色，各个segment就是对应着各个数据库。
在这里插入图片描述

准备阶段

  • coordinator向所有参与的数据库发出预处理请求prepare，并开始等待各参与者的响应。
  • 各参与者执行本地事务，执行完成后并不会真正提交，也不会释放资源，而是先向coordinator报告结果，是否可以commit。
  • coordinator接收到所有的参与者的反馈后，决定是否继续完成commit。
    整个准备阶段只要有任一参与者没有正确响应，就会导致事务abort，而coordinator需要记录相关的日志信息。

提交/回滚阶段

  • coordinator向所有参与者发出commit/rollback请求
  • 各参与者收到commit/rollback请求之后，正式的执行本地事务的commit操作并记录日志，然后释放相关的资源。最后回复coordinator执行结果
  • coordinator收到所有参与者的回复之后，记录日志并释放资源。

两阶段提交相关结构

GlobalTransactionData

全局事务数据结构体，保存每个事务相关的数据，数据库启动后，会初始化max_prepared_transactions个GlobalTransactionData结构，并以链表的形式存储到TwoPhaseStateData结构体的freeGxacts中
该结构体主要记录了三部分内容：

  • 两阶段提交相关的信息，比如指向的下一个GlobalTransaction地址，进程信息，事务开始时间等
  • XLOG信息，事务ID信息及用户信息
  • 标志位，比如是否记录到PGPROC中，是否落盘，数据是否是从WAL日志中获得等
typedef struct GlobalTransactionData
{
	GlobalTransaction next;		/* TwophaseStateData的freeGxacts链表 */
	int			pgprocno;		/* PGPROC，在initPRoc时会初始化 */
	BackendId	dummyBackendId; /* dummy进程，用来代表一个backend */
	TimestampTz prepared_at;	/* prepared事务开始的时间 */

	XLogRecPtr	prepare_start_lsn;	/* prepared记录的XLOG日志的起始位置 */
	XLogRecPtr	prepare_end_lsn;	/* prepared记录的XLOG日志的结束位置 */
	TransactionId xid;			/* 全局事务ID */

	Oid			owner;			/* 启动这个事务的用户 */
	BackendId	locking_backend;	/* 当前事务事务中运行的事务ID */
	bool		valid;			/* 当前进程是在PGPROC中记录 */
	bool		ondisk;			/* Prepare状态数据是否落盘 */
	bool		inredo;			/* 数据内容是否是通过回放WAL日志获得 */
	char		gid[GIDSIZE];	/* prepared transaction指定的gid */
}			GlobalTransactionData;

TwoPhaseStateData

数据库在启动时初始化的一个全局变量，记录了两阶段提交事务需要用到的GlobalTransactionData结构的使用情况。比如空闲链表，已使用的个数，已使用的GlobalTransactionData的地址。

typedef struct TwoPhaseStateData
{
	/* Head of linked list of free GlobalTransactionData structs */
	GlobalTransaction freeGXacts;  //空闲链表，存储的是可用的GlobalTransactionData结构

	/* Number of valid prepXacts entries. */
	int			numPrepXacts; //当前的有效的2PC事务的个数

	/* There are max_prepared_xacts items in this array */
	GlobalTransaction prepXacts[FLEXIBLE_ARRAY_MEMBER]; //当时使用的2PC的GlobalTransactionData的地址
} TwoPhaseStateData;

共享内存中存储格式

数据库启动时会初始化一个全局共享变量TwoPhaseState和max_prepared_transactions个GlobalTransactionData结构体，所有的GlobalTransactionData是以链表的形式保存，TwoPhaseState的成员freeGXacts指向链表的头部。当启动一个两阶段提交事务时，就会从freeGxacts的链表中取下一个空闲的GlobalTransactionData用来保存当前的2PC的事务信息，同时TwoPhaseState中的numprepXacts计数加1，并会将GlobalTransactionData地址保存到prepXacts数组中。当两阶段提交事务提交后，会重置其使用的GlobalTransactionData结构体，并将其重新插入到freeGxacts链表中，同时numpreXacts计数减1，并清除prepXacts数组中对应的元素。
在这里插入图片描述

2PC的代码执行流程

参照上面的使用示例，接下来分析一下执行PREPARE命令，COMMIT命令和ROLLBACK命令后代码执行流程。

prepare阶段

执行PrePare transaction命令后，实际执行的就是执行PrepareTransaction函数

  • PrepareTransaction
    执行PrepareTransaction函数，进行Prepare相关操作。该函数执行完之后，相关数据就已经写入WAL日志且刷入磁盘中了，即使重启数据库数据也不会丢失，只不过事务状态是未提交的，对其他事务来时还是不可见的。需要注意的是，在Prepare后，这个2PC事务添加的锁也不会释放，即使重启数据库，重启后锁依然存在。
  1. 事务启动前的准备工作，跟正常的事务启动差不多
  	TransactionState s = CurrentTransactionState; //获取当前的事务
	TransactionId xid = GetCurrentTransactionId(); //获取当前的事务ID，如果不存在就分配一个，也就是两阶段提交必然会分配事务ID
    ...
	s->state = TRANS_PREPARE; //事务状态更新为prepare
	prepared_at = GetCurrentTimestamp(); //获取当前的时间作为两阶段提交创建时间戳
	BufmgrCommit();//啥也没干
  1. 从共享内存链表TwoPhaseState中获取一个空闲的GlobalTransactionData并初始化得到一个全局事务状态变量gxact
   	gxact = MarkAsPreparing(xid, prepareGID, prepared_at,
							GetUserId(), MyDatabaseId); //获取到一个全局的GXact
  1. 启动两阶段提交事务，并进行相应处理，如将当前事务的record写入XLOG中，并由checkpointer控制是否刷盘（手动创建checkpoint会写pg_twophase目录）
   StartPrepare(gxact);//初始化2PC文件头数据
	AtPrepare_Notify();//已经执行LISTEN、UNLISTEN、NOTIFY的话不允许2PC
	AtPrepare_Locks();//记录当前所有的持有的锁信息
	AtPrepare_PredicateLocks();//记录所有的predicate lock信息
	AtPrepare_PgStat();//记录2PC相关的统计信息
	AtPrepare_MultiXact();//记录MultiXact信息
	AtPrepare_RelationMap();//2PC 不允许任何relation Map修改
	EndPrepare(gxact);//2PC真正执行的东西
  1. 2PC 事务执行结束后的清理，
    标记当前的gxact为prepared，并标记事务状态为in_progress，添加到ProcGlobal共享内存中，该事务所在的proc被添加到全局的ProcGlobal中，该事务会被认为是in progress的，也就是说这个事务的修改并不会被其他事务看到。
	PostPrepare_Locks(xid);//将我们持有的锁保存到PGPROC中
	ProcArrayClearTransaction(MyProc);//清理事务
    ...
	PostPrepare_Twophase();//彻底与进程解耦
	s->fullTransactionId = InvalidFullTransactionId;
	s->subTransactionId = InvalidSubTransactionId;
	s->nestingLevel = 0;
	s->gucNestLevel = 0;
	s->childXids = NULL;
	s->nChildXids = 0;
	s->maxChildXids = 0;

	XactTopFullTransactionId = InvalidFullTransactionId;
	nParallelCurrentXids = 0;
	s->state = TRANS_DEFAULT; //事务状态修改为default

	RESUME_INTERRUPTS();
  • MarkAsPreparing
    • 检查是否开启2PC，检查gid是否有冲突
    • 检查是否还有空闲2PC空间
    • 从freeGxacts链表上取下一个空闲的gxact并进行初始化
 	/* fail immediately if feature is disabled */
	//只有GUC参数max_prepared_transactions参数不为0才能使用两阶段提交
	if (max_prepared_xacts == 0)
		ereport(ERROR,
				(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
				 errmsg("prepared transactions are disabled"),
				 errhint("Set max_prepared_transactions to a nonzero value.")));



	LWLockAcquire(TwoPhaseStateLock, LW_EXCLUSIVE);//获取LWlock，因为要访问全局变量TwoPhaseState

	//检查是否有GUD冲突
	for (i = 0; i < TwoPhaseState->numPrepXacts; i++)
	{
		gxact = TwoPhaseState->prepXacts[i];
		if (strcmp(gxact->gid, gid) == 0) //判断名字是否有冲突
		{
			ereport(ERROR,
					(errcode(ERRCODE_DUPLICATE_OBJECT),
					 errmsg("transaction identifier \"%s\" is already in use",
							gid)));
		}
	}

	/* 从全局的空闲链表中获取一个空闲的GXACT */
	if (TwoPhaseState->freeGXacts == NULL)
		ereport(ERROR,
				(errcode(ERRCODE_OUT_OF_MEMORY),
				 errmsg("maximum number of prepared transactions reached"),
				 errhint("Increase max_prepared_transactions (currently %d).",
						 max_prepared_xacts)));
	gxact = TwoPhaseState->freeGXacts;//从freelist上取一个GXact
	TwoPhaseState->freeGXacts = gxact->next; //全局的指向下一个

	MarkAsPreparingGuts(gxact, xid, gid, prepared_at, owner, databaseid);//初始化gxact以及对应的proc

	gxact->ondisk = false; //是否落盘，初始化为false
	TwoPhaseState->prepXacts[TwoPhaseState->numPrepXacts++] = gxact;//将选择的GXact地址保存到数据中，方便遍历

	LWLockRelease(TwoPhaseStateLock);//释放锁

	return gxact;
  • EndPrepare
    该函数将完成两阶段提交的所有准备并写入到WAL日志。
  • 注册数据到record中
  • 确保WAL的registerbuffer有足够的空间
  • 填充数据到record中
  • 插入到WAL buffer中
  • 将WAL buffer中数据刷入磁盘
  • 标记该两阶段提交事务为有效，将当前进程信息加入到ProcGlobal中
	RegisterTwoPhaseRecord(TWOPHASE_RM_END_ID, 0,
						   NULL, 0); //注册到record中，用于写入到2PL文件

	XLogEnsureRecordSpace(0, records.num_chunks);//保证register_buffers有足够的空间
	for (record = records.head; record != NULL; record = record->next)
		XLogRegisterData(record->data, record->len);//填充数据
	gxact->prepare_end_lsn = XLogInsert(RM_XACT_ID, XLOG_XACT_PREPARE);//插入XLOG数据
	XLogFlush(gxact->prepare_end_lsn);//WAL日志刷盘
	MarkAsPrepared(gxact, false);//标记为可用，并将进程加到ProcGlobal中

commit/rollback阶段

执行commit prepared ‘p1’,提交prepare事务,或执行rollback prepared 'p1’都是执行FinishPreparedTransaction函数实现

  1. 通过传入的gid从共享内存中的TwoPhaseState中找到gxact
  2. 从XLOG或pg_twophase中读取gxact对应的数据到buffer中
  3. 通过RecordTransactionCommitPrepared函数写commit标记到XLOG中，并标记当前事务状态为committed。
  4. 通过ProcArrayRemove从共享内存变量ProcGlobal中移除当前proc，这样对其他事务就可见了
  5. 发送IM消息到其他的cache，标记当前tuple已经被更新，需要重新读取填充。
  6. 提交成功，清理锁信息以及从TwoPhaseState中移除gxact
	if (gxact->ondisk) //如果已经落盘到2PL文件中，则从pg_twophase中读取数据
		buf = ReadTwoPhaseFile(xid, false);
	else //从XLOG中读取数据
		XlogReadTwoPhaseData(gxact->prepare_start_lsn, &buf, NULL);

	latestXid = TransactionIdLatest(xid, hdr->nsubxacts, children); //获取最新的事务ID
	if (isCommit)
		RecordTransactionCommitPrepared(xid,hdr->nsubxacts, children,
			hdr->ncommitrels, commitrels,hdr->ninvalmsgs, invalmsgs,
			hdr->initfileinval, gid); //记录事务提交信息,会写XLOG
	else
		RecordTransactionAbortPrepared(xid,
			hdr->nsubxacts, children,hdr->nabortrels, abortrels,
			gid);//记录事务abort信息

	ProcArrayRemove(proc, latestXid); //将proc信息从ProcArray中删除
	DropRelationFiles(delrels, ndelrels, false); //删除标记为droped的文件
	SendSharedInvalidMessages(invalmsgs, hdr->ninvalmsgs); //IM消息相关
	PredicateLockTwoPhaseFinish(xid, isCommit); //释放2PC的锁
	RemoveGXact(gxact); //从TwoPhase全局变量中删除
	if (gxact->ondisk)
		RemoveTwoPhaseFile(xid, true); //删除pg_twophase下的对应文件

2PC的checkpoint

checkpoint定时进行checkpoint定时将buffer中的内容刷入到磁盘，其中也会将2两阶段提交的WAL日志信息刷入到磁盘中。这里只会将WAL写入pg_twophase目录下。
正常情况下，两阶段提交事务的数据会在Prepare 命令执行完调用的Endprepare函数中奖事务相关数据写入WAL日志中并刷入磁盘。但是如果在Prepare transaction执行过程中，在执行Endprepare前，checkpointer就触发了，那么就会触发刷WAL日志数据数据到磁盘的。
如果PrePare transaction执行时没有跨过检查点，那么只需要将两阶段数据保存到WAL日志中即可，但是如果跨过了检查点，由于checkpointer会触发WAL日志的刷盘和清理，所以有可能删除2PC产生的WAL日志。因此需要将检查点之前的相关WAL日志保存到数据目录的pg_twophase目录下，文件名以事务ID的8位16进制值命名。

  • CheckPointTwoPhase
    • 申请2PC的锁
    • 遍历每一个2PC事务
    • 如果2PC中的end_lsn小于redo点，则将这部分WAL日志保存到pg_twophase目录下下
    • 释放2PC的锁
    • pg_twophase目录下文件sync

	 */
	LWLockAcquire(TwoPhaseStateLock, LW_SHARED);
	//将所有的2PL相关WAL数据刷入磁盘
	for (i = 0; i < TwoPhaseState->numPrepXacts; i++)
	{
		GlobalTransaction gxact = TwoPhaseState->prepXacts[i];

		if ((gxact->valid || gxact->inredo) &&
			!gxact->ondisk &&
			gxact->prepare_end_lsn <= redo_horizon) //只会将LSN小于checkpoint的redo point时才会写入2PL文件，否则不用写，会刷入WAL日志中
		{
			char	   *buf;
			int			len;

			XlogReadTwoPhaseData(gxact->prepare_start_lsn, &buf, &len); //从XLOG中读取2PL数据
			RecreateTwoPhaseFile(gxact->xid, buf, len); //创建2PL文件，文件名以事务ID的16进制值命名
			gxact->ondisk = true;
			gxact->prepare_start_lsn = InvalidXLogRecPtr;
			gxact->prepare_end_lsn = InvalidXLogRecPtr;
			pfree(buf); //从XLOG读数据的时候分配的空间，这里要释放掉
			serialized_xacts++;
		}
	}
	LWLockRelease(TwoPhaseStateLock);

	fsync_fname(TWOPHASE_DIR, true); //刷入磁盘

【参考】

  1. 《PostgreSQL数据库内核分析》
  2. 《Postgresql技术内幕-事务处理深度探索》
  3. pg14源码
Week_by_week
关注
  • 26
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
分布式基础之二阶段提交
DRFish
01-04 2095
分布式基础之二阶段提交二阶段提交（Two Phase Commit）在分布式事务处理中非常常见。它主要用来保证分布式事务处理的一致性，决定事务的提交或回滚。目前二阶段提交广泛应用于关系型数据库的分布式事务处理中，它是分布式系统中的一个常见协议。需求为什么要二阶段提交？因为在分布式系统中，每个节点只知道自己的事务是否执行成功了，而分布式系统要求一致性，也就是所有的节点的状态都应该一致。如果某一个事务只
PostgreSQL-分布式事务之两阶段提交
贾欣晓的博客
05-13 1487
在分布式系统中，事务中往往包含了多台数据库上的操作，虽然单台数据库的操作能够保证原子性，但多台数据库之间的原子性就需要通过两阶段提交来实现了，两阶段提交是实现分布式事务的关键。
Greenplum 源码解析 两阶段提交
Serendipity_Shy
10-15 904
greenplum源码解析
如何在PostgreSQL中实现分布式事务，特别是在多节点集群环境中？
最新发布
程序员墨松
04-25 574
在Citus中，你需要定义哪些表是分布式的，以及它们的分布键是什么。分布键是用于在节点之间分割数据的列。在PostgreSQL中实现分布式事务需要一些额外的工具和配置。Citus是一个强大的选项，它允许你轻松地将PostgreSQL转变为一个分布式数据库，并支持跨节点的分布式事务。通过安装和配置Citus，定义分布式表和分布键，然后像平常一样执行SQL语句，你就可以在PostgreSQL中实现分布式事务了。相关阅读推荐PostgreSQL入门到精通.PDF 领取Postgres专栏推荐。
greenplum中的二阶段提交
qq_37517281的博客
07-22 585
以 create table 为例 master 节点先在自己节点上创建这个表（包括更新 pg_class 缓存，创建物理文件等），再向各节点 dispatch 命令 （参考）。 在结束事务时（finish_xact_command->CommitTransactionCommand）触发二阶段提交： 第一阶段 prepareDtxTransaction 检查序列化冲突 （PreCommit_CheckForSerializationFailure） 向segment 发送信息 “Distribut
postgresql集群方案hot standby初级测试(五)——xlog详细解释record
玩命写博客
08-07 3411
上一篇文章讲了下xlog的头部，今天详细讲解下record部分，希望这两篇文章对研究postgresql的xlog的同学有所帮助： 本文来自：http://blog.csdn.net/lengzijian/article/details/7840332 首先看下XLOG日志记录结构： XLogRecord记录了XLOG的相关控制信息，数据结构如下：
PostgreSQL中的两阶段提交
万里归来少年心
10-17 3033
    在分布式系统中，事务往往包含了多台数据库上的操作。多台数据库之间的原子性，需要通过两阶段提交协议来实现。     两阶段提交协议的步骤： （1）应用程序调用事务协调器中的提交方法。 （2）事务协调器将联络事务中涉及的所有数据库，通知它们准备提交事务（PREPARE TRANSACTION）。 （3）数据库收到通知后，确保后续在被要求提交事务时能提交，或在被要求回滚事务时能回滚，则返...
PostgreSQL创建事务、开启归档及用户赋权
君子不怨天的博客
08-23 1170
archive_command 参数值是一个脚本，或一个命令，PG通过执行它来完成归档动作。archive_mode 为ON表示开启归档模式，修改需要重启PG生效。授予htuser对ws_user的usage和select权限。测试结果发现一个没有提交的事务在窗口被关闭以后事务会被。在归档后执行命令，拷贝归档到/pgarch目录。已提交的事务会持久化保存到数据库中。创建归档存放新路径/pgarch。a：插入（append）d：删除（delete）修改拷贝目的端目录属主。w：更新（write）
安川变频器PG-X3手册.pdf
04-12
安川变频器PG-X3手册.pdf 安川变频器PG-X3手册是一份英文版用户手册，主要介绍了PG-X3型号的相关信息，包括尺寸、接线定义、接线原理图等。下面是从该手册中提取的相关知识点： 1. 安川变频器PG-X3概述：PG-X3是...
VC_过启动_内核过pg读写_过启动项_过pg保护_启动项_
10-01
标题中的“VC_过启动_内核过pg读写_过启动项_过pg保护_启动项_”指的是与Windows操作系统、内核级保护以及启动管理相关的技术话题。在这个场景中，“VC”可能是Visual C++的简称，一种常用于开发Windows系统应用的...
pg_manager:PostgreSQL企业管理器
05-26
适用于9.X及更高版本的PostgreSQL企业管理器 语言：Groovy，Java和HMTL 5 屏幕截图 安装步骤 应用环境 JDK 8 Tomcat7 server.xml：添加数据源资源并配置 <Resource name="jdbc/pgman" auth="Container" ...
pg_probackup：PostgreSQL备份和恢复管理器
02-05
pg_probackup是一个实用程序，用于管理PostgreSQL数据库集群的备份和恢复。 它旨在执行PostgreSQL实例的定期备份，使您能够在发生故障时还原服务器。 该实用程序兼容： PostgreSQL 9.5、9.6、10、11、12、13; 与...
pg_partman：PostgreSQL分区管理扩展
02-05
pg_partman是用于创建和管理基于时间和基于序列的表分区集的扩展。 从pg_partman v3.0.1开始支持PostgreSQL 10的本机分区，而从PostgreSQL 11开始从4.0.0起更广泛的支持。请注意，本机尚不支持基于触发器的分区的...
PG事务：隔离级别基础
liuzhilong的博客
05-20 949
在众多关系型数据库中，pg的事务机制非常有特色，了解pg的事务机制是了解pg数据库运行原理的关键。
Postgresql事务和Greenplum中的两阶段提交
u013970710的博客
10-06 1491
PostgreSQL是当今最广泛应用的数据库系统(DBMS)之一。除了由于其具有优秀的性能、良好的兼容性之外，其完全开源的特性、完整的事务能力也是其中重要的原因。PostgreSQL支持完整的ACID特性，支持RC/RR/SSI等隔离级别。 本文主要简化的介绍PG的事务模型和Greenplum基于两阶段提交的分布式事务。具体地，本文会首先介绍单机事务、ACID特性，以及PG中的事务实现；然后介绍一种分布式事务协议——两阶段提交协议，分析其实现、优点和局限性，并简单介绍以3PC为代表的两阶段提交协议优化。
POstgres的两阶段提交
文档搬运工
08-20 686
-- 将max_prepared_transactions设置为大于0 mydb=# show max_prepared_transactions; max_prepared_transactions --------------------------- 20 (1 row) mydb=# -- 创建一个表 create table t1 (id int primary key,name text); -- 启动一个事务，插入数据 begin; insert into t1 ..
XA两阶段提交协议
热门推荐
张晓
09-29 1万+
因为事务需要实现ACID，即原子性、一致性、隔离性、持久性，所以需要采用一定的机制来保证，通常采用的是分阶段提交的方式。    XA:XA协议，规定事务管理器和资源管理器接口，采用二阶段提交协议。 一阶段提交协议     一阶段提交协议相对简单，如下图：                     当然，前提是开启了事务，然后在应用程序发出提交/回滚请求后，数据库执行操作，而后将成功/
来了，大话分布式：分布式事务（CAP、两阶段提交、三阶段提交）
wdjnb的博客
12-24 1457
1 关于分布式系统 1.1 介绍 我们常见的单体结构的集中式系统，一般整个项目就是一个独立的应用，所有的模块都聚合在一起。明显的弊端就是不易扩展、发布冗重、服务治理不好做。 所以我们把整个系统拆分成若干个具备独立运行能力的计算机服务的集合，而从用户的角度看，是一个完整的系统，但实际上，它是一个分布式服务的集合。 分布式系统主要从以下几个方面进行裂变： 应用可以从业务领域拆分成多个module，每个module还可以再按项目结构分成接口层、业务层、数据访问层；当然也可以按访问入口进行拆分，如移动、桌
pg数据库查最大提交事务
10-22
该参数表示在两阶段提交中可以同时准备的最大事务数。可以通过以下SQL语句查询该参数的值： ``` SHOW max_prepared_transactions; ``` 该命令将返回一个整数值，表示当前PG数据库中可以同时准备的最大事务数。如果...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值