
# PG_THREAD_WAIT_STATUS
通过PG_THREAD_WAIT_STATUS视图可以检测当前实例中工作线程（backend thread）以及辅助线程（auxiliary thread）的阻塞等待情况。多租场景下，non-PDB访问该视图时返回全部信息，PDB访问该视图时仅返回该PDB相关信息。
表1PG_THREAD_WAIT_STATUS字段 
| 名称               | 类型      | 描述                                                                                                                                                                                              |
|:---|:---|:---|
| node_name        | text    | 当前节点的名称。                                                                                                                                                                                        |
| db_name          | text    | 数据库名称。                                                                                                                                                                                          |
| thread_name      | text    | 线程名称。                                                                                                                                                                                           |
| query_id         | bigint  | 查询ID，对应debug_query_id。                                                                                                                                                                          |
| tid              | bigint  | 当前线程的线程号。                                                                                                                                                                                       |
| sessionid        | bigint  | 当前会话ID。                                                                                                                                                                                         |
| lwtid            | integer | 当前线程的轻量级线程号。                                                                                                                                                                                    |
| psessionid       | bigint  | 父会话ID。                                                                                                                                                                                          |
| tlevel           | integer | streaming线程的层级。                                                                                                                                                                                 |
| smpid            | integer | 并行线程的ID。                                                                                                                                                                                        |
| wait_status      | text    | 当前线程的等待状态。等待状态的详细信息请参见[表2]。 |
| wait_event       | text    | 如果wait_status是acquire lock、acquire lwlock、wait io三种类型，此列描述具体的锁、轻量级锁、IO的信息。否则是空。                                                                                                                 |
| locktag          | text    | 当前线程正等待获取的锁的信息。                                                                                                                                                                                 |
| lockmode         | text    | 当前线程正等待获取的锁的模式。包含表级锁、行级锁、页级锁下的各模式。                                                                                                                                                              |
| block_sessionid  | bigint  | 阻塞当前线程获取锁的会话标识。                                                                                                                                                                                 |
| global_sessionid | text    | 全局会话ID。                                                                                                                                                                                         |
   
wait_status列的等待状态有以下状态。
 表2等待状态列表 
| wait_status值                                        | 含义                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
|:---|:---|
| none                                                | 没在等任意事件。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| acquire lock                                        | 等待加锁，要么加锁成功，要么加锁等待超时。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| acquire lwlock                                      | 等待获取轻量级锁。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| wait io                                             | 等待IO完成。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| wait cmd                                            | 等待完成读取网络通信包。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| wait pooler get conn                                | 等待pooler完成获取连接。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| wait pooler abort conn                              | 等待pooler完成终止连接。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| wait pooler clean conn                              | 等待pooler完成清理连接。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| pooler create conn: \[nodename\], total N           | 等待pooler建立连接，当前正在与nodename指定节点建立连接，且仍有N个连接等待建立。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| get conn                                            | 获取到其他节点的连接。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| set cmd: \[nodename\]                               | 在连接上执行SET/RESET/TRANSACTION BLOCK LEVEL PARA SET/SESSION LEVEL PARA SET，当前正在nodename指定节点上执行。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| cancel query                                        | 取消某连接上正在执行的SQL语句。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| stop query                                          | 停止某连接上正在执行的查询。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| wait node: \[nodename\](plevel), total N, \[phase\] | 等待接收与某节点的连接上的数据，当前正在等待nodename节点plevel线程的数据，且仍有N个连接的数据待返回。如果状态包含phase信息，则可能的阶段状态有： - begin：表示处于事务开始阶段。  - commit：表示处于事务提交阶段。  - rollback：表示处于事务回滚阶段。   |
| wait transaction sync: xid                          | 等待xid指定事务同步。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| wait wal sync                                       | 等待特定LSN的wal log完成到备机的同步。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| wait data sync                                      | 等待完成数据页到备机的同步。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| wait data sync queue                                | 等待把行存的数据页放入同步队列。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| flush data: \[nodename\](plevel), \[phase\]         | 等待向网络中nodename指定节点的plevel对应线程发送数据。如果状态包含phase信息，则可能的阶段状态为wait quota，即当前通信流正在等待quota值。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| stream get conn: \[nodename\], total N              | 初始化stream flow时，等待与nodename节点的consumer对象建立连接，且当前有N个待建连对象。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| wait producer ready: \[nodename\](plevel), total N  | 初始化stream flow时，等待每个producer都准备好，当前正在等待nodename节点plevel对应线程的producer对象准备好，且仍有N个producer对象处于等待状态。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| synchronize quit                                    | stream plan结束时，等待stream线程组内的线程统一退出。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| wait stream nodegroup destroy                       | stream plan结束时，等待销毁stream node group。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| wait active statement                               | 等待作业执行，正在资源负载管控中。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| analyze: \[relname\], \[phase\]                     | 当前正在对表relname执行analyze。如果状态包含phase信息，则为autovacuum，表示是数据库自动开启AutoVacuum线程执行的analyze分析操作。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| vacuum: \[relname\], \[phase\]                      | 当前正在对表relname执行vacuum。如果状态包含phase信息，则为autovacuum，表示是数据库自动开启AutoVacuum线程执行的vacuum清理操作。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| vacuum full: \[relname\]                            | 当前正在对表relname执行vacuum full清理。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| create index                                        | 当前正在创建索引。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| HashJoin - \[ build hash \| write file \]           | 当前是HashJoin算子，主要关注耗时的执行阶段。 - build hash：表示当前HashJoin算子正在建立哈希表。  - write file：表示当前HashJoin算子正在将数据写入磁盘。                                                                                                                                                                                                                                                                                                           |
| HashAgg - \[ build hash \| write file \]            | 当前是HashAgg算子，主要关注耗时的执行阶段。 - build hash：表示当前HashAgg算子正在建立哈希表。  - write file：表示当前HashAgg算子正在将数据写入磁盘。                                                                                                                                                                                                                                                                                                                  |
| HashSetop - \[build hash \| write file \]           | 当前是HashSetop算子，主要关注耗时的执行阶段。 - build hash：表示当前HashSetop算子正在建立哈希表。  - write file：表示当前HashSetop算子正在将数据写入磁盘。                                                                                                                                                                                                                                                                                                         |
| Sort \| Sort - \[fetch tuple \| write file\]        | 当前是Sort算子做排序，fetch tuple表示Sort算子正在获取tuple，write file表示Sort算子正在将数据写入磁盘。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| Material \| Material - write file                   | 当前是Material算子，write file表示Material算子正在将数据写入磁盘。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| NestLoop                                            | 当前是NestLoop算子。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| wait memory                                         | 等待内存获取。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| wait sync consumer next step                        | Stream算子等待消费者执行。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| wait sync producer next step                        | Stream算子等待生产者执行。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| vacuum gpi                                          | vacuum或者autovacuum流程中global partition index清理。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| standby read recovery conflict                      | 备机只读与日志回放产生冲突。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| standby get snapshot                                | 备机只读获取快照。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| prune table                                         | 等待堆表清理历史删除数据。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| prune index                                         | 等待索引清理历史删除数据。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| wait reserve td                                     | 等待分配ustore事务槽。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| wait td rollback                                    | 等待ustore事务槽回滚。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| wait available td                                   | 等待ustore可用的事务槽。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| wait transaction rollback                           | 等待事务回滚。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| wait sync bgworkers                                 | 等待并行创建索引的子线程完成本地扫描和排序。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| wait io control                                     | 等待作业执行，正在I/O管控中。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| wait gs_sleep                                       | 等待服务器线程延迟时间。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| wait vacuum delay                                   | 等待vacuum延迟时间。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| wait seq scan                                       | seq scan执行时间。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| wait index scan                                     | index scan执行时间。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| wait checkpoint start                               | checkpoint开始阶段时间。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| wait checkpoint done                                | checkpoint结束阶段时间。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| wait xact start command                             | xact开始时间。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| wait xact commit command                            | xact提交时间。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| wait for autoextend partition                       | 等待分区表自动扩展创建分区。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| Accept client conn - Total Time                     | GaussDB数据库接受客户端的连接请求时，从建立连接开始到连接成功过程的整体耗时。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| Accept client conn - ThrdPool - add epoll           | GaussDB数据库接受客户端的连接请求时，线程池模式下，从建立连接开始，到线程池将session的句柄加入到epoll的耗时。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| Accept client conn - ThrdPool - wait worker         | GaussDB数据库接受客户端的连接请求时，线程池模式下，从线程池将session的句柄加入到epoll开始，到线程池中工作线程开始工作的耗时。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| Accept client conn - ThrdPool - init session        | GaussDB数据库接受客户端的连接请求时，线程池模式下，从线程池中工作线程开始工作，到session初始化结束的耗时。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| Accept client conn - Worker - init proc             | GaussDB数据库接受客户端的连接请求时，非线程池模式下，从建立连接开始，到线程初始化结束的耗时。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| Accept client conn - Worker - init session          | GaussDB数据库接受客户端的连接请求时，非线程池模式下，从线程初始化结束，到session初始化结束的耗时。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| security audit write pipe                           | 等待将审计日志写入管道。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| wait fetch undo record                              | 等待读取目标undo记录。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| wait heap hot search buffer                         | 等待通过hot链读取满足快照的Astore 元组。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| wait exclusive lwlock                               | 防饿死机制触发，新的轻量级锁加锁请求等待之前被阻塞的轻量级锁获取到。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| deadlock check                                      | 在等待死锁检测过程中，将持有全部分区的LockMgrLock锁资源。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| wal wait flush                                      | 主机中等待Xlog落盘以及DCF模式下与备机达成共识，备机中等待刷新完最小恢复点以及DCF模式下跟主机达成共识。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
   
当wait_status为acquire lwlock、acquire lock或者wait io时，表示有等待事件。正在等待获取wait_event列对应类型的轻量级锁、事务锁，或者正在进行IO。
其中，wait_status值为acquire lwlock（轻量级锁）时对应的wait_event等待事件类型与描述信息如下。（wait_event为extension时，表示此时的轻量级锁是动态分配的锁，未被监控。）
表3轻量级锁等待事件列表 
| wait_event类型                             | 类型描述                                        |
|:---|:---|
| ShmemIndexLock                           | 用于保护共享内存中的主索引哈希表。                           |
| OidGenLock                               | 用于避免不同线程产生相同的OID。                           |
| XidGenLock                               | 用于避免两个事务获得相同的xid。                           |
| ProcArrayLock                            | 用于避免并发访问或修改ProcArray共享数组。                   |
| SInvalReadLock                           | 用于避免与清理失效消息并发执行。                            |
| SInvalWriteLock                          | 用于避免与其它写失效消息、清理失效消息并发执行。                    |
| WALInsertLock                            | 用于避免与其它WAL插入操作并发执行。                         |
| WALWriteLock                             | 用于避免并发WAL写盘。                                |
| ControlFileLock                          | 用于避免pg_control文件的读写并发、写写并发。                 |
| CheckpointLock                           | 用于避免多个checkpoint并发执行。                       |
| CLogControlLock                          | 用于避免并发访问或者修改Clog控制数据结构。                     |
| SubtransControlLock                      | 用于避免并发访问或者修改子事务控制数据结构。                      |
| MultiXactGenLock                         | 用于串行分配唯一MultiXact id。                       |
| MultiXactOffsetControlLock               | 用于避免对pg_multixact/offset的写写并发和读写并发。         |
| MultiXactMemberControlLock               | 用于避免对pg_multixact/members的写写并发和读写并发。        |
| RelCacheInitLock                         | 用于失效消息场景对init文件进行操作时加锁。                     |
| CheckpointerCommLock                     | 用于向checkpointer发起文件刷盘请求场景，需要串行的向请求队列插入请求结构。 |
| TwoPhaseStateLock                        | 用于避免并发访问或者修改两阶段信息共享数组。                      |
| TablespaceCreateLock                     | 用于确定tablespace是否已经存在。                       |
| BtreeVacuumLock                          | 用于防止vacuum清理B-tree中还在使用的页面。                 |
| AutovacuumLock                           | 用于串行化访问autovacuum worker数组。                 |
| AutovacuumScheduleLock                   | 用于串行化分配需要vacuum的table。                      |
| AutoanalyzeLock                          | 用于获取和释放允许执行Autoanalyze的任务资源。                |
| SyncScanLock                             | 用于确定heap扫描时某个relfilenode的起始位置。              |
| NodeTableLock                            | 用于保护存放数据库节点信息的共享结构。                         |
| PoolerLock                               | 用于保证两个线程不会同时从连接池里取到相同的连接。                   |
| RelationMappingLock                      | 用于等待更新系统表到存储位置之间映射的文件。                      |
| Async Ctl                                | 用于保护Async buffer。                           |
| AsyncCtlLock                             | 用于避免并发访问或者修改共享通知状态。                         |
| AsyncQueueLock                           | 用于避免并发访问或者修改共享通知信息队列。                       |
| SerializableXactHashLock                 | 用于避免对于可串行事务共享结构的写写并发和读写并发。                  |
| SerializableFinishedListLock             | 用于避免对于已完成可串行事务共享链表的写写并发和读写并发。               |
| SerializablePredicateLockListLock        | 用于保护对于可串行事务持有的锁链表。                          |
| OldSerXidLock                            | 用于保护记录冲突可串行事务的结构。                           |
| FileStatLock                             | 用于保护存储统计文件信息的数据结构。                          |
| SyncRepLock                              | 用于在主备复制时保护xlog同步信息。                         |
| DataSyncRepLock                          | 用于在主备复制时保护数据页同步信息。                          |
| MetaCacheSweepLock                       | 用于元数据循环淘汰。                                  |
| ExtensionConnectorLibLock                | 用于初始化ODBC连接场景，在加载与卸载特定动态库时进行加锁。             |
| SearchServerLibLock                      | 用于GPU加速场景初始化加载特定动态库时，对读文件操作进行加锁。            |
| LsnXlogChkFileLock                       | 用于串行更新特定结构中记录的主备机的xlog flush位置点。            |
| ReplicationSlotAllocationLock            | 用于主备复制时保护主机端的流复制槽的分配。                       |
| ReplicationSlotControlLock               | 用于主备复制时避免并发更新流复制槽状态。                        |
| ResourcePoolHashLock                     | 用于避免并发访问或者修改资源池哈希表。                         |
| WorkloadStatHashLock                     | 用于避免并发访问或者修改包含数据库主节点的SQL请求构成的哈希表。           |
| WorkloadIoStatHashLock                   | 用于避免并发访问或者修改用于统计当前数据库节点的IO信息的哈希表。           |
| WorkloadCGroupHashLock                   | 用于避免并发访问或者修改Cgroup信息构成的哈希表。                 |
| OBSGetPathLock                           | 用于避免对obs路径的写写并发和读写并发。                       |
| WorkloadUserInfoLock                     | 用于避免并发访问或修改负载管理的用户信息哈希表。                    |
| WorkloadRecordLock                       | 用于避免并发访问或修改在内存自适应管理时对数据库主节点收到请求构成的哈希表。      |
| WorkloadIOUtilLock                       | 用于保护记录iostat，CPU等负载信息的结构。                   |
| WorkloadNodeGroupLock                    | 用于避免并发访问或者修改内存中的nodegroup信息构成的哈希表。          |
| JobShmemLock                             | 用于定时任务功能中保护定时读取的全局变量。                       |
| OBSRuntimeLock                           | 用于获取环境变量，如GAUSSHOME。                        |
| LLVMDumpIRLock                           | 用于导出动态生成函数所对应的汇编语言。                         |
| LLVMParseIRLock                          | 用于在查询开始处从IR文件中编译并解析已写好的IR函数。                |
| CriticalCacheBuildLock                   | 用于从共享或者本地缓存初始化文件中加载cache的场景。                |
| WaitCountHashLock                        | 用于保护用户语句计数功能场景中的共享结构。                       |
| BufMappingLock                           | 用于保护对共享缓冲映射表的操作。                            |
| LockMgrLock                              | 用于保护常规锁结构信息。                                |
| PredicateLockMgrLock                     | 用于保护可串行事务锁结构信息。                             |
| OperatorRealTLock                        | 用于避免并发访问或者修改记录算子级实时数据的全局结构。                 |
| OperatorHistLock                         | 用于避免并发访问或者修改记录算子级历史数据的全局结构。                 |
| SessionRealTLock                         | 用于避免并发访问或者修改记录query级实时数据的全局结构。              |
| SessionHistLock                          | 用于避免并发访问或者修改记录query级历史数据的全局结构。              |
| BarrierLock                              | 用于保证当前只有一个线程在创建Barrier。                     |
| dummyServerInfoCacheLock                 | 用于保护缓存加速数据库连接信息的全局哈希表。                      |
| RPNumberLock                             | 用于加速GaussDB的数据库节点对正在执行计划的任务线程的计数。           |
| CBMParseXlogLock                         | Cbm解析xlog时的保护锁                              |
| RelfilenodeReuseLock                     | 避免错误地取消已重用的列属性文件的链接。                        |
| RcvWriteLock                             | 防止并发调用WalDataRcvWrite。                      |
| PercentileLock                           | 用于保护全局PercentileBuffer                      |
| CSNBufMappingLock                        | 保护csn页面                                     |
| UniqueSQLMappingLock                     | 用于保护uniquesql hash table                    |
| DelayDDLLock                             | 防止并发ddl。                                    |
| CLOG Ctl                                 | 用于避免并发访问或者修改Clog控制数据结构                      |
| Async Ctl                                | 保护Async buffer                              |
| MultiXactOffset Ctl                      | 保护MultiXact offset的slru buffer              |
| MultiXactMember Ctl                      | 保护MultiXact member的slrubuffer               |
| OldSerXid SLRU Ctl                       | 保护old xids的slru buffer                      |
| ReplicationSlotLock                      | 用于保护ReplicationSlot                         |
| PGPROCLock                               | 用于保护pgproc                                  |
| MetaCacheLock                            | 用于保护MetaCache                               |
| DataCacheLock                            | 用于保护datacache                               |
| InstrUserLock                            | 用于保护InstrUserHTAB。                          |
| BadBlockStatHashLock                     | 用于保护global_bad_block_stat hash表。            |
| BufFreelistLock                          | 用于保证共享缓冲区空闲列表操作的原子性。                        |
| AddinShmemInitLock                       | 保护共享内存对象的初始化。                               |
| AlterPortLock                            | 保护协调节点更改注册端口号的操作。                           |
| FdwPartitionCacheLock                    | HDFS分区表缓冲区的管理锁。                             |
| DfsConnectorCacheLock                    | DFSConnector缓冲区的管理锁。                        |
| DfsSpaceCacheLock                        | HDFS表空间管理缓冲区的管理锁。                           |
| FullBuildXlogCopyStartPtrLock            | 用于保护全量Build中Xlog复制的操作。                      |
| DfsUserLoginLock                         | 用于HDFS用户登录以及认证。                             |
| LogicalReplicationSlotPersistentDataLock | 用于保护逻辑复制过程中复制槽位的数据。                         |
| PgfdwLock                                | 用于管理实例向Foreign server建立连接。                  |
| InstanceTimeLock                         | 用于获取实例中会话的时间信息。                             |
| XlogRemoveSegLock                        | 保护Xlog段文件的回收操作。                             |
| DnUsedSpaceHashLock                      | 用于更新会话对应的空间使用信息。                            |
| CsnMinLock                               | 用于计算CSNmin。                                 |
| GPCCommitLock                            | 用于保护全局Plan Cache hash表的添加操作。                |
| GPCClearLock                             | 用于保护全局Plan Cache hash表的清除操作。                |
| GPCTimelineLock                          | 用于保护全局Plan Cache hash表检查Timeline的操作。        |
| InstanceRealTLock                        | 用于保护共享实例统计信息hash表的更新操作。                     |
| CLogBufMappingLock                       | 用于提交日志缓存管理。                                 |
| GPCMappingLock                           | 用于全局Plan Cache缓存管理。                         |
| GPCPrepareMappingLock                    | 用于全局Plan Cache缓存管理。                         |
| BufferIOLock                             | 保护共享缓冲区页面的IO操作。                             |
| BufferContentLock                        | 保护共享缓冲区页面内容的读取、修改。                          |
| CSNLOG Ctl                               | 用于CSN日志管理。                                  |
| DoubleWriteLock                          | 用于双写的管理操作。                                  |
| RowPageReplicationLock                   | 用于管理行存储的数据页复制。                              |
| MatviewSeqnoLock                         | 用于物化视图缓存管理。                                 |
| GPRCMappingLock                          | 用于管理自治事务全局缓存hash表的访问和修改操作。                  |
| extension                                | 其他轻量锁。                                      |
| wait active statement                    | 等待作业执行，正在资源负载管控中。                           |
| wait memory                              | 等待内存获取。                                     |
| IOStatLock                               | 用于资源管理IO统计信息哈希表并发维护操作。                      |
| StartBlockMappingLock                    | 用于globalstat从pgstat获取startblockarray等信息     |
| PldebugLock                              | 用于存储过程调试并发维护操作                              |
| DataFileIdCacheLock                      | 管理共享内存中存储数据文件描述符的哈希表的并发访存。                  |
| GTMHostInfoLock                          | 保护共享GTM主机信息的并发访存。                           |
| TwoPhaseStatePartLock                    | 保护（各个分区）两阶段事务状态信息。                          |
| WALBufMappingLock                        | 保护共享内中各个wal缓存页面与lsn偏移的映射关系。                 |
| UndoZoneLock                             | 保护undozone的并发访存。                            |
| RollbackReqHashLock                      | 管理共享内存中存储回滚请求信息的哈希表的并发访存。                   |
| UHeapStatLock                            | 保护ustore统计信息的并发访存。                          |
| WALWritePaxosLock                        | 保护向paxos复制组件写wal日志的并发顺序。                    |
| SyncPaxosLock                            | 保护paxos同步队列的并发访存。                           |
| BackgroundWorkerLock                     | 保护background worker的并发顺序。                   |
| HadrSwitchoverLock                       | 保护容灾切换的并发顺序。                                |
| HashUidLock                              | 保护uid分配的并发顺序。                               |
| ParallelDecodeLock                       | 保护并行解码的并发顺序。                                |
| XLogMaxCSNLock                           | 保护容灾模式下本地最大可恢复CSN信息。                        |
| DisasterCacheLock                        | 保护共享内存中容灾信息缓存的并发访存。                         |
| MaxCSNArrayLock                          | 保护共享内存中各个分片备机CSN恢复进度信息。                     |
| RepairBadBlockStatHashLock               | 保护共享内存中损坏页面哈希表的并发访存。                        |
| HypoIndexLock                            | 虚拟索引创建、删除、重置等动作中使用的轻量级锁。                    |
| XGBoostLibLock                           | DB4AI特性调用xgboost库时启用的锁。                     |
| DropArchiveSlotLock                      | 保护删除归档槽信息的并发顺序                              |
| ProcXactMappingLock                      | 保护事务号到线程信息映射哈希表的并发访存。                       |
| UndoPerZoneLock                          | 保护每个undozone内信息的并发访存。                       |
| UndoSpaceLock                            | 保护undospace的并发访存。                           |
| SnapshotBlockLock                        | 控制快照备份与页面刷盘的并发顺序。                           |
| DWSingleFlushFirstLock                   | 控制非段页式单页面双写文件的并发顺序。                         |
| DWSingleFlushSecondLock                  | 控制段页式单页面双写文件的并发顺序。                          |
| DWSingleFlushSecondBufTagLock            | 控制段页式单页面双写文件的元信息并发访存。                       |
| RestartPointQueueLock                    | 控制备机restart Point数组的并发访存。                   |
| UnlinkRelHashTblLock                     | 保护共享内存中待删除文件哈希表的并发访存。                       |
| UnlinkRelForkHashTblLock                 | 保护共享内存中待删除文件fork哈希表的并发访存。                   |
| WALFlushWait                             | 保护日志刷盘的并发顺序。                                |
| WALConsensusWait                         | 保护日志达成一致才进行事务提交或日志回放操作。                     |
| WALBufferInitWait                        | 保护wal共享内存页面的初始化和刷盘顺序。                       |
| WALInitSegment                           | 保护wal日志段文件的初始化顺序。                           |
| SegmentHeadPartitionLock                 | 保护段页式segment头部元信息的分区锁。                      |
| PgwrSyncQueueLock                        | 保护待刷盘文件队列的并发访存。                             |
| BarrierHashTblLock                       | 保护共享内存中barrier列表信息的并发访存。                    |
| PageRepairHashTblLock                    | 保护页面修复哈希表的并发访存。                             |
| FileRepairHashTblLock                    | 保护文件修复哈希表的并发访存。                             |
| InstrUserLockId                          | 对保护用户登录登出哈希表并发修改加锁。                         |
| GsStackLock                              | 控制gs_stack函数不会被并发调用。                        |
| InstrStmtTrackCtlLock                    | 在动态开启全量SQL时，保护哈希表的并发访存。                     |
| CaptureViewFileHashLock                  | 开启性能视图采集时，保护哈希表的并发访存。                       |
| UniqueSqlEvictLock                       | 开启Unique SQL回收时，保护哈希表的并发访存。                 |
| gtt_shared_ctl                           | 用于保护全局临时表共享哈希表并发读写。                         |
| AuditIndexFileLock                       | 控制审计日志index文件的并发读写。                         |
| TDEKeyCacheLock                          | 控制透明加密数据密钥缓存的并发读写。                          |
| BlockchainVersionLock                    | 账本数据库中控制全局区块号的并发读写。                         |
| GlobalPrevHashLock                       | 账本数据库中控制全局校验哈希的并发读写。                        |
| LWTRANCHE_ACCOUNT_TABLE                  | 控制账户锁定状态hash表的并发读写。                         |
   
当wait_status值为wait io时对应的wait_event等待事件类型与描述信息如下。
表4IO等待事件列表 
| wait_event类型                    | 类型描述                                                                     |
|:---|:---|
| BufFileRead                     | 从临时文件中读取数据到指定buffer。                                                     |
| BufFileWrite                    | 向临时文件中写入指定buffer中的内容。                                                    |
| ControlFileRead                 | 读取pg_control文件。主要在数据库启动、执行checkpoint和主备校验过程中发生。                          |
| ControlFileSync                 | 将pg_control文件持久化到磁盘。数据库初始化时发生。                                           |
| ControlFileSyncUpdate           | 将pg_control文件持久化到磁盘。主要在数据库启动、执行checkpoint和主备校验过程中发生。                     |
| ControlFileWrite                | 写入pg_control文件。数据库初始化时发生。                                                |
| ControlFileWriteUpdate          | 更新pg_control文件。主要在数据库启动、执行checkpoint和主备校验过程中发生。                          |
| CopyFileRead                    | copy文件时读取文件内容。                                                           |
| CopyFileWrite                   | copy文件时写入文件内容。                                                           |
| DataFileExtend                  | 扩展文件时向文件写入内容。                                                            |
| DataFileFlush                   | 将表数据文件持久化到磁盘                                                             |
| DataFileImmediateSync           | 将表数据文件立即持久化到磁盘。                                                          |
| DataFilePrefetch                | 异步读取表数据文件。                                                               |
| DataFileRead                    | 同步读取表数据文件。                                                               |
| DataFileSync                    | 将表数据文件的修改持久化到磁盘。                                                         |
| DataFileTruncate                | 表数据文件truncate。                                                           |
| DataFileWrite                   | 向表数据文件写入内容。                                                              |
| LockFileAddToDataDirRead        | 读取"postmaster.pid"文件。                                                    |
| LockFileAddToDataDirSync        | 将"postmaster.pid"内容持久化到磁盘。                                               |
| LockFileAddToDataDirWrite       | 将pid信息写到"postmaster.pid"文件。                                              |
| LockFileCreateRead              | 读取LockFile文件"%s.lock"。                                                   |
| LockFileCreateSync              | 将LockFile文件"%s.lock"内容持久化到磁盘。                                            |
| LockFileCreateWRITE             | 将pid信息写到LockFile文件"%s.lock"。                                             |
| RelationMapRead                 | 读取系统表到存储位置之间的映射文件                                                        |
| RelationMapSync                 | 将系统表到存储位置之间的映射文件持久化到磁盘。                                                  |
| RelationMapWrite                | 写入系统表到存储位置之间的映射文件。                                                       |
| ReplicationSlotRead             | 读取流复制槽文件。重新启动时发生。                                                        |
| ReplicationSlotRestoreSync      | 将流复制槽文件持久化到磁盘。重新启动时发生。                                                   |
| ReplicationSlotSync             | checkpoint时将流复制槽临时文件持久化到磁盘。                                              |
| ReplicationSlotWrite            | checkpoint时写流复制槽临时文件。                                                    |
| SLRUFlushSync                   | 将pg_clog、pg_subtrans和pg_multixact文件持久化到磁盘。主要在执行checkpoint和数据库停机时发生。      |
| SLRURead                        | 读取pg_clog、pg_subtrans和pg_multixact文件。                                    |
| SLRUSync                        | 将脏页写入文件pg_clog、pg_subtrans和pg_multixact并持久化到磁盘。主要在执行checkpoint和数据库停机时发生。 |
| SLRUWrite                       | 写入pg_clog、pg_subtrans和pg_multixact文件。                                    |
| TimelineHistoryRead             | 读取timeline history文件。在数据库启动时发生。                                          |
| TimelineHistorySync             | 将timeline history文件持久化到磁盘。在数据库启动时发生。                                     |
| TimelineHistoryWrite            | 写入timeline history文件。在数据库启动时发生。                                          |
| TwophaseFileRead                | 读取pg_twophase文件。在两阶段事务提交、两阶段事务恢复时发生。                                     |
| TwophaseFileSync                | 将pg_twophase文件持久化到磁盘。在两阶段事务提交、两阶段事务恢复时发生。                                |
| TwophaseFileWrite               | 写入pg_twophase文件。在两阶段事务提交、两阶段事务恢复时发生。                                     |
| WALBootstrapSync                | 将初始化的WAL文件持久化到磁盘。在数据库初始化发生。                                              |
| WALBootstrapWrite               | 写入初始化的WAL文件。在数据库初始化发生。                                                   |
| WALCopyRead                     | 读取已存在的WAL文件并进行复制时产生的读操作。在执行归档恢复完后发生。                                     |
| WALCopySync                     | 将复制的WAL文件持久化到磁盘。在执行归档恢复完后发生。                                             |
| WALCopyWrite                    | 读取已存在WAL文件并进行复制时产生的写操作。在执行归档恢复完后发生。                                      |
| WALInitSync                     | 将新初始化的WAL文件持久化磁盘。在日志回收或写日志时发生。                                           |
| WALInitWrite                    | 将新创建的WAL文件初始化为0。在日志回收或写日志时发生。                                            |
| WALRead                         | 从xlog日志读取数据。两阶段文件redo相关的操作产生。                                            |
| WALSyncMethodAssign             | 将当前打开的所有WAL文件持久化到磁盘。                                                     |
| WALWrite                        | 写入WAL文件。                                                                 |
| WALBufferAccess                 | WAL Buffer访问（出于性能考虑，内核代码里只统计访问次数，未统计其访问耗时）。                              |
| WALBufferFull                   | WAL Buffer满时，写wal文件相关的处理。                                                |
| DoubleWriteFileRead             | 双写 文件读取。                                                                 |
| DoubleWriteFileSync             | 双写 文件强制刷盘。                                                               |
| DoubleWriteFileWrite            | 双写 文件写入。                                                                 |
| PredoProcessPending             | 并行日志回放中当前记录回放等待其它记录回放完成。                                                 |
| PredoApply                      | 并行日志回放中等待当前工作线程等待其他线程回放至本线程LSN。                                          |
| DisableConnectFileRead          | HA锁分片逻辑文件读取。                                                             |
| DisableConnectFileSync          | HA锁分片逻辑文件强制刷盘。                                                           |
| DisableConnectFileWrite         | HA锁分片逻辑文件写入。                                                             |
| BufHashTableSearch              | 共享缓冲区hash表搜索（可能会触发页面淘汰）。                                                 |
| buffer_strategy_get             | 策略化缓冲区页面获取（可能会触发页面淘汰）。                                                   |
| UndoFileExtend                  | undo文件扩展。                                                                |
| UndoFilePrefetch                | undo文件预取。                                                                |
| UndoFileRead                    | undo文件读取。                                                                |
| UndoFileWrite                   | undo文件写。                                                                 |
| UndoFileSync                    | undo文件刷盘。                                                                |
| UndoFileUnlink                  | undo文件删除。                                                                |
| UndoMetaSync                    | undo元数据文件刷盘。                                                             |
| DWSingleFlushGetPos             | 单页面双写文件查找可用位置。                                                           |
| DWSingleFlushWrite              | 单页面双写文件刷盘。                                                               |
| CkptWaitPageWriterFlush         | 执行全量checkpoint时等待刷页。                                                     |
| CkptWaitPageWriterSync          | checkpoint打点前等待有修改的文件同步进磁盘。                                              |
| CkptWaitCommitTransactionFinish | checkpoint打点前等待所有已经提交的事务提交完毕。                                            |
| MPFL_INIT                       | 初始化max_page_flush_lsn。                                                   |
| MPFL_READ                       | 读取max_page_flush_lsn。                                                    |
| MPFL_WRITE                      | 写max_page_flush_lsn。                                                     |
| OBSList                         | 遍历OBS目录。                                                                 |
| OBSRead                         | 读取OBS对象。                                                                 |
| OBSWrite                        | 写入OBS对象。                                                                 |
| LOGCTRL_SLEEP                   | 等待备机回放追赶。                                                                |
| ShareStorageWalRead             | 共享盘读取日志文件。                                                               |
| ShareStorageWalWrite            | 共享盘写入日志文件。                                                               |
| ShareStorageCtlInfoRead         | 共享盘读取控制信息。                                                               |
| ShareStorageCtlInfoWrite        | 共享盘写入控制信息。                                                               |
| SegFileExtend                   | 段页式文件扩展。                                                                 |
| SegReadDisk                     | 段页式文件读取。                                                                 |
| SegWriteDisk                    | 段页式文件写入。                                                                 |
| SegSync                         | 段页式文件刷盘。                                                                 |
| SegFileShrink                   | 段页式文件收缩。                                                                 |
   
当wait_status值为acquire lock（事务锁）时对应的wait_event等待事件类型与描述信息如下。
表5事务锁等待事件列表 
| wait_event类型     | 类型描述                 |
|:---|:---|
| relation         | 对表加锁。                |
| extend           | 对表扩展空间时加锁。           |
| partition        | 对分区表加锁。              |
| partition_seq    | 对分区表的分区加锁。           |
| page             | 对表页面加锁。              |
| tuple            | 对页面上的tuple加锁。        |
| transactionid    | 对事务ID加锁。             |
| virtualxid       | 对虚拟事务ID加锁。           |
| object           | 加对象锁。                |
| userlock         | 加用户锁。                |
| advisory         | 加advisory锁。          |
| filenode         | 对文件名加锁，控制文件级操作的并发顺序。 |
| subtransactionid | 对子事务号加锁。             |
| tuple_uid        | 对元组uid隐藏字段加锁。        |
   
