【PostgreSQL创建索引的锁分析和使用注意】

1.1 创建普通B-tree索引的整体流程

如下是梳理的创建普通B-tree索引的大概流程，可供参考。

1.校验新索引的Catalog元数据|语法解析  ---将创建索引的sql解析成IndexStmt结构｜校验B-Tree的handler   -----校验内核是否支持该类型的索引,在pg_am中查找"btree"对应的handler｜校验索引列及比较函数   ----查找pg_attribute，校验create index中指定的索引列是否存在，如果存在记录attno，并且根据atttypid（表示表中列的字段类型）在pg_opclass里查找对应的比较函数2.在文件系统中创建索引文件｜生成oid  ---为新的索引文件生成唯一oid，过程是：生成一个新的oid，然后查找pg_class的索引，如果不存在就返回这个oid｜更新本地的relcache   ---正在创建的relation添加到relcache｜创建索引文件以及写xlog   ----文件系统中生成新的文件 base/xxx/xxx。xlog记录类型为XLogInsert(RM_SMGR_ID, XLOG_SMGR_CREATE | XLR_SPECIAL_REL_UPDATE)3.创建新索引的元数据｜索引作为对象的元数据写入到pg_class ｜索引文件引用的列插入pg_attribute｜索引本身相关信息插入pg_index|relcache失效，invalid所有heap相关的元数据  ---为了使catalog元数据的变更对所有进程生效｜记录该索引对heap的依赖，对opclass的依赖等等插入pg_depend｜使得新索引文件相关的relcache生效4.用函数btbuild构建B-tree索引｜通过index的索引列构建排序时需要用到的sortkey，扫描tuple生成索引元组数组｜ 构建B+树叶节点｜对索引元组执行排序｜将排序成功的结点依次插入到B-Tree中，自下向上构建B-Tree索引page --依次读取排好序的tuple，填充到B-Tree的叶子节点上，自下向上插入B-Tree

1.2 锁相关介绍

PostgreSQL里有很多可以加锁的对象：表、单个页、单个元组、事务ID（包括虚拟和永久ID）和普通数据库对象等等，常规锁的locktype主要有以下几种。有时候通过pg_locks查询的时候，根据pid会查到许多的锁，但是这些锁并不一定都是加在表上的，根据locktype以及relation过滤出不同对象上的锁。

/** LOCKTAG is the key information needed to look up a LOCK item in the* lock hashtable.  A LOCKTAG value uniquely identifies a lockable object.** The LockTagType enum defines the different kinds of objects we can lock.* We can handle up to 256 different LockTagTypes.*/
typedef enum LockTagType
{LOCKTAG_RELATION,			/* whole relation */LOCKTAG_RELATION_EXTEND,	/* the right to extend a relation */LOCKTAG_DATABASE_FROZEN_IDS,	/* pg_database.datfrozenxid */LOCKTAG_PAGE,				/* one page of a relation */LOCKTAG_TUPLE,				/* one physical tuple */LOCKTAG_TRANSACTION,		/* transaction (for waiting for xact done) */LOCKTAG_VIRTUALTRANSACTION, /* virtual transaction (ditto) */LOCKTAG_SPECULATIVE_TOKEN,	/* speculative insertion Xid and token */LOCKTAG_OBJECT,				/* non-relation database object */LOCKTAG_USERLOCK,			/* reserved for old contrib/userlock code */LOCKTAG_ADVISORY			/* advisory user locks */
} LockTagType;

image20240104174056577.png

如下是PostgreSQL里的常规锁，其中AccessShareLock、RowShareLock、RowExclusiveLock属于弱锁，ShareLock、ShareRowExclusiveLock、ExclusiveLock 、AccessExclusiveLock属于强锁。

/* NoLock is not a lock mode, but a flag value meaning "don't get a lock" */
#define NoLock 0
#define AccessShareLock 1 /* SELECT */
#define RowShareLock 2 /* SELECT FOR UPDATE/FOR SHARE */
#define RowExclusiveLock 3 /* INSERT, UPDATE, DELETE */
#define ShareUpdateExclusiveLock 4 /* VACUUM (non-FULL),ANALYZE, CREATE * INDEX CONCURRENTLY */
#define ShareLock 5 /* CREATE INDEX (WITHOUT CONCURRENTLY) */
#define ShareRowExclusiveLock 6 /* like EXCLUSIVE MODE, but allows ROW * SHARE */
#define ExclusiveLock 7 /* blocks ROW SHARE/SELECT...FOR * UPDATE */
#define AccessExclusiveLock 8 /* ALTER TABLE, DROP TABLE, VACUUM * FULL, and unqualified LOCK TABLE */

1.3 创建普通索引表上需要获取的锁(ShareLock)

使用如下的语句进行测试

postgres=# create table tab_test_1(id int);
CREATE TABLE
postgres=# insert into tab_test_1 values(1);
INSERT 0 1
postgres=# insert into tab_test_1 values(2);
INSERT 0 1
postgres=# insert into tab_test_1 values(3);
INSERT 0 1
postgres=# begin;
BEGIN
postgres=*# create index idx_1 on tab_test_1(id);
CREATE INDEX
postgres=*#

普通创建索引获取ShareLock，是5级锁，这里通过SQL可以查询到，其实在创建索引的过程中，不仅原始的表上会申请锁。对应的几张系统表和系统表索引上也会申请锁，因为创建索引也涉及到系统表元数据的校验和更改，这里访问pg_namespace的意义在于：索引将与其父表位于同一命名空间中。

当有多个事务同时对表进行读操作时，如果不做任何锁定，会导致数据不一致。例如，一个事务在读取数据时，另一个事务做了修改，然后第一个事务读到的数据已经不是最新的。这时候就需要使用AccessShareLock来控制并发的读取操作，保持数据的一致性。

postgres=# select l.locktype,ns.nspname,a.relname,a.relkind,l.pid,l.mode,l.granted,p.query_start,p.query,p.state from pg_locks l,pg_stat_activity p,pg_class a,pg_namespace ns where l.locktype='relation' and l.pid=p.pid and query not like '%pg_stat_activity%' and l.relation=a.oid and a.relnamespace=ns.oid;locktype |  nspname   |              relname              | relkind |  pid   |      mode       | granted |          query_start          |query                 |        state
----------+------------+-----------------------------------+---------+--------+-----------------+---------+-------------------------------+-----------
----------------------------+---------------------relation | public     | tab_test_1                        | r       | 409706 | ShareLock       | t       | 2024-01-04 11:48:11.807816+08 | create index idx_1 on tab_test_1(id); | idle in transactionrelation | pg_catalog | pg_class                          | r       | 409706 | AccessShareLock | t       | 2024-01-04 11:48:11.807816+08 | create index idx_1 on tab_test_1(id); | idle in transactionrelation | pg_catalog | pg_namespace                      | r       | 409706 | AccessShareLock | t       | 2024-01-04 11:48:11.807816+08 | create index idx_1 on tab_test_1(id); | idle in transactionrelation | pg_catalog | pg_namespace_nspname_index        | i       | 409706 | AccessShareLock | t       | 2024-01-04 11:48:11.807816+08 | create index idx_1 on tab_test_1(id); | idle in transactionrelation | pg_catalog | pg_namespace_oid_index            | i       | 409706 | AccessShareLock | t       | 2024-01-04 11:48:11.807816+08 | create index idx_1 on tab_test_1(id); | idle in transactionrelation | pg_catalog | pg_class_oid_index                | i       | 409706 | AccessShareLock | t       | 2024-01-04 11:48:11.807816+08 | create index idx_1 on tab_test_1(id); | idle in transactionrelation | pg_catalog | pg_class_relname_nsp_index        | i       | 409706 | AccessShareLock | t       | 2024-01-04 11:48:11.807816+08 | create index idx_1 on tab_test_1(id); | idle in transactionrelation | pg_catalog | pg_class_tblspc_relfilenode_index | i       | 409706 | AccessShareLock | t       | 2024-01-04 11:48:11.807816+08 | create index idx_1 on tab_test_1(id); | idle in transaction
(8 rows)

1.4 关于ShareLock的其他场景

在源码的注释部分，可以看到CREATE INDEX (WITHOUT CONCURRENTLY) 的时候会在表上申请ShareLock，这和我们的测试结果相符合，但是ShareLock不仅仅创建索引的时候会获取，当多个事务更新同一行的时候，也会申请ShareLock，不过这个ShareLock不是在表级别申请的，而是在分配事务ID时对这个事务ID进行加锁， 用于元组并发更新时做事务等待。

分别用两个session做如下操作：

//session 1,pid：434865postgres=# begin;
BEGIN
postgres=*# update tab_test_1 set id=7 where id=1;
UPDATE 1
postgres=*#//session 2,pid：433290postgres=# begin;
BEGIN
postgres=*# update tab_test_1 set id=7 where id=1;

然后用另一个session查询锁的状态

postgres=# select * from pg_locks where pid='434865';locktype    | database | relation | page | tuple | virtualxid | transactionid | classid | objid | objsubid | virtualtransaction |  pid   |       mode| granted | fastpath | waitstart
---------------+----------+----------+------+-------+------------+---------------+---------+-------+----------+--------------------+--------+--------------
----+---------+----------+-----------relation      |    13008 |    16725 |      |       |            |               |         |       |          | 3/16               | 434865 | RowExclusiveL
ock | t       | t        |virtualxid    |          |          |      |       | 3/16       |               |         |       |          | 3/16               | 434865 | ExclusiveLock| t       | t        |transactionid |          |          |      |       |            |          1699 |         |       |          | 3/16               | 434865 | ExclusiveLock| t       | f        |
(3 rows)postgres=# select * from pg_locks where pid='433290';locktype    | database | relation | page | tuple | virtualxid | transactionid | classid | objid | objsubid | virtualtransaction |  pid   |       mode| granted | fastpath |           waitstart
---------------+----------+----------+------+-------+------------+---------------+---------+-------+----------+--------------------+--------+--------------
----+---------+----------+-------------------------------relation      |    13008 |    16725 |      |       |            |               |         |       |          | 4/3                | 433290 | RowExclusiveLock | t       | t        |virtualxid    |          |          |      |       | 4/3        |               |         |       |          | 4/3                | 433290 | ExclusiveLock| t       | t        |transactionid |          |          |      |       |            |          1700 |         |       |          | 4/3                | 433290 | ExclusiveLock| t       | f        |tuple         |    13008 |    16725 |    0 |     1 |            |               |         |       |          | 4/3                | 433290 | ExclusiveLock| t       | f        |transactionid |          |          |      |       |            |          1699 |         |       |          | 4/3                | 433290 | ShareLock| f       | f        | 2024-01-04 13:33:16.667889+08
(5 rows)

可以通过上述测试看到，pid为433290的这个session，它的pg_locks的最后一行 的granted为’f’,说明该进程被阻塞，并且是在申请类型为tansactionid的锁时被阻塞了，对应tansactionid=1699的事务。从表上可以看出这个tansactionid已经被进程pid为434865的session1会话持有了。

行锁的阻塞信息是通过tansactionid类型的锁体现的，行锁是会在数据行上加自己的tansactionid的，另一个进程读到这一行时，如果发现上一个操作该行的事务未结束，会把上一个事务的tansactionid读出来，然后申请在这个tansactionid上加上ShareLock，等待上一个事务结束，再获得ExclusiveLock。而持有行锁的进程已经在此tansactionid上加了ExclusiveLock，所以后面要更新这行的进程会被阻塞。

ShareLock即读锁，ExclusiveLock即写锁。对事务ID加ShareLock是为了事务不提交，其他人看不到修改后的行，而ExclusiveLock是防止并发操作的。

1.5 创建普通索引时阻塞的一些操作

如下是对创建普通索引申请的ShareLock后的一些阻塞情况

1.5.1 建普通索引阻塞DML操作
//开一个session,开启事务创建索引，然后不提交postgres=# begin;
BEGIN
postgres=*# create index idx_1 on tab_test_1(id);
CREATE INDEX
postgres=*#//新开一个session，查询这张表,可以正常访问，不阻塞读
postgres=# select * from tab_test_1 ;id
----123
(3 rows)//新开多个session，分别做dml操作
//session A：
postgres=# insert into tab_test_1 values(6);
//session B：
postgres=# update tab_test_1 set id=7 where id=1;
//session C：
postgres=# delete from tab_test_1 where id=1;//另开一个session，查看获取的锁postgres=#  select l.locktype,ns.nspname,a.relname,a.relkind,l.pid,l.mode,l.granted,p.query_start,p.query,p.state from pg_locks l,pg_stat_activity p,pg_class a,pg_namespace ns where l.locktype='relation' and l.pid=p.pid and query not like '%pg_stat_activity%' and l.relation=a.oid and a.relnamespace=ns.oid and a.relname='tab_test_1';locktype | nspname |  relname   | relkind |  pid   |       mode       | granted |          query_start          |                 query                  |state
----------+---------+------------+---------+--------+------------------+---------+-------------------------------+----------------------------------------+
---------------------relation | public  | tab_test_1 | r       | 409706 | ShareLock        | t       | 2024-01-04 11:48:11.807816+08 | create index idx_1 on tab_test_1(id);  |idle in transactionrelation | public  | tab_test_1 | r       | 410009 | RowExclusiveLock | f       | 2024-01-04 12:48:34.640655+08 | insert into tab_test_1 values(6);      |activerelation | public  | tab_test_1 | r       | 420570 | RowExclusiveLock | f       | 2024-01-04 12:48:37.450632+08 | update tab_test_1 set id=7 where id=1; |activerelation | public  | tab_test_1 | r       | 420581 | RowExclusiveLock | f       | 2024-01-04 12:48:39.828598+08 | delete from tab_test_1 where id=1;     |active
(4 rows)//以及查看阻塞源，可以看到表上的dml操作都是被create index 给阻塞了。pid   | blocked_by |  state  |       wait        | wait_age |  tx_age  | xid_age |   xmin_ttf    | datname  | usename  | blkd |                       que
ry
--------+------------+---------+-------------------+----------+----------+---------+---------------+----------+----------+------+--------------------------
--------------------------409706 | {}         | idletx  | Client:ClientRead |          | 01:02:44 | 5       |               | postgres | postgres |    3 |  [409706] create index idx_1 on tab_test_1(id);410009 | {409706}   | waiting | Lock:relation     | 00:01:57 | 00:01:57 |         | 2,147,483,642 | postgres | postgres |    0 |  [410009] . insert into tab_test_1 values(6);420570 | {409706}   | waiting | Lock:relation     | 00:01:54 | 00:01:54 |         | 2,147,483,642 | postgres | postgres |    0 |  [420570] . update tab_test_1 set id=7 where id=1;420581 | {409706}   | waiting | Lock:relation     | 00:01:51 | 00:01:51 |         | 2,147,483,642 | postgres | postgres |    0 |  [420581] . delete from tab_test_1 where id=1;
(4 rows)
1.5.2 建普通索引阻塞DDL操作
//开一个session,开启事务创建索引，然后不提交postgres=# begin;
BEGIN
postgres=*# create index idx_1 on tab_test_1(id);
CREATE INDEX
postgres=*#//新开一个session，执行DDL操作，alter table加列postgres=# alter table tab_test_1 add column name varchar(20);//另开一个session，查看获取的锁
postgres=#  select l.locktype,ns.nspname,a.relname,a.relkind,l.pid,l.mode,l.granted,p.query_start,p.query,p.state from pg_locks l,pg_stat_activity p,pg_class a,pg_namespace ns where l.locktype='relation' and l.pid=p.pid and query not like '%pg_stat_activity%' and l.relation=a.oid and a.relnamespace=ns.oid and a.relname='tab_test_1';locktype | nspname |  relname   | relkind |  pid   |        mode         | granted |          query_start          |                        query|        state
----------+---------+------------+---------+--------+---------------------+---------+-------------------------------+--------------------------------------
---------------+---------------------relation | public  | tab_test_1 | r       | 409706 | ShareLock           | t       | 2024-01-04 11:48:11.807816+08 | create index idx_1 on tab_test_1(id);| idle in transactionrelation | public  | tab_test_1 | r       | 422658 | AccessExclusiveLock | f       | 2024-01-04 12:51:52.948432+08 | alter table tab_test_1 add column nam
e varchar(20); | active
(2 rows)//查看阻塞源，可以看到表上alter table加列的DDL操作被create index给阻塞了。pid   | blocked_by |  state  |       wait        | wait_age |  tx_age  | xid_age |   xmin_ttf    | datname  | usename  | blkd |query
--------+------------+---------+-------------------+----------+----------+---------+---------------+----------+----------+------+--------------------------
---------------------------------------409706 | {}         | idletx  | Client:ClientRead |          | 01:04:09 | 6       |               | postgres | postgres |    1 |  [409706] create index idx_1 on tab_test_1(id);422658 | {409706}   | waiting | Lock:relation     | 00:00:03 | 00:00:03 | 1       | 2,147,483,641 | postgres | postgres |    0 |  [422658] . alter table tab_test_1 add column name varchar(20);
(2 rows)//新开一个session，执行DDL操作，drop table删除表
postgres=# drop table tab_test_1;//另开一个session，查看获取的锁postgres=#  select l.locktype,ns.nspname,a.relname,a.relkind,l.pid,l.mode,l.granted,p.query_start,p.query,p.state from pg_locks l,pg_stat_activity p,pg_class a,pg_namespace ns where l.locktype='relation' and l.pid=p.pid and query not like '%pg_stat_activity%' and l.relation=a.oid and a.relnamespace=ns.oid and a.relname='tab_test_1';locktype | nspname |  relname   | relkind |  pid   |        mode         | granted |          query_start          |                 query|        state
----------+---------+------------+---------+--------+---------------------+---------+-------------------------------+--------------------------------------
-+---------------------relation | public  | tab_test_1 | r       | 409706 | ShareLock           | t       | 2024-01-04 11:48:11.807816+08 | create index idx_1 on tab_test_1(id);| idle in transactionrelation | public  | tab_test_1 | r       | 422669 | AccessExclusiveLock | f       | 2024-01-04 12:53:17.664053+08 | drop table tab_test_1;| active
(2 rows)//查看阻塞源，可以看到表上drop table删除表的DDL操作被create index给阻塞了。pid   | blocked_by |  state  |       wait        | wait_age |  tx_age  | xid_age |   xmin_ttf    | datname  | usename  | blkd |                      quer
y
--------+------------+---------+-------------------+----------+----------+---------+---------------+----------+----------+------+--------------------------
-----------------------409706 | {}         | idletx  | Client:ClientRead |          | 01:05:43 | 7       |               | postgres | postgres |    1 |  [409706] create index idx_1 on tab_test_1(id);422669 | {409706}   | waiting | Lock:relation     | 00:00:12 | 00:00:12 | 1       | 2,147,483,640 | postgres | postgres |    0 |  [422669] . drop table tab_test_1;
(2 rows)
1.5.3 阻塞vacuum,vacuum full,analyze
//开一个session,开启事务创建索引，然后不提交postgres=# begin;
BEGIN
postgres=*# create index idx_1 on tab_test_1(id);
CREATE INDEX
postgres=*#//新开一个session，vacuum该表postgres=# vacuum tab_test_1;//另开一个session，查看获取的锁postgres=# select l.locktype,ns.nspname,a.relname,a.relkind,l.pid,l.mode,l.granted,p.query_start,p.query,p.state from pg_locks l,pg_stat_activity p,pg_class a,pg_namespace ns where l.locktype='relation' and l.pid=p.pid and query not like '%pg_stat_activity%' and l.relation=a.oid and a.relnamespace=ns.oid;locktype | nspname |  relname   | relkind |  pid   |           mode           | granted |          query_start          |                 query|        state
----------+---------+------------+---------+--------+--------------------------+---------+-------------------------------+---------------------------------
------+---------------------relation | public  | tab_test_1 | r       | 452619 | ShareLock                | t       | 2024-01-04 14:50:00.524497+08 | create index idx_1 on tab_test_1
(id); | idle in transactionrelation | public  | tab_test_1 | r       | 452585 | ShareUpdateExclusiveLock | f       | 2024-01-04 14:50:35.244644+08 | vacuum tab_test_1 ;| active
(2 rows)//查看阻塞源，可以看到表vacuum操作被create index给阻塞了。pid   | blocked_by |  state  |       wait        | wait_age |  tx_age  | xid_age |   xmin_ttf    | datname  | usename  | blkd |                      quer
y
--------+------------+---------+-------------------+----------+----------+---------+---------------+----------+----------+------+--------------------------
-----------------------452619 | {}         | idletx  | Client:ClientRead |          | 00:00:40 | 1       |               | postgres | postgres |    1 |  [452619] create index id
x_1 on tab_test_1(id);452585 | {452619}   | waiting | Lock:relation     | 00:00:02 | 00:00:02 |         | 2,147,483,646 | postgres | postgres |    0 |  [452585] . vacuum tab_te
st_1 ;
(2 rows)

可以看到vacuum改表被create index阻塞了，vacuum full，analyze测试方法类似，也是一样被阻塞了。

//阻塞vacuum fullpid   | blocked_by |  state  |       wait        | wait_age |  tx_age  | xid_age |   xmin_ttf    | datname  | usename  | blkd |                      quer
y
--------+------------+---------+-------------------+----------+----------+---------+---------------+----------+----------+------+--------------------------
-----------------------452619 | {}         | idletx  | Client:ClientRead |          | 00:12:38 | 2       |               | postgres | postgres |    1 |  [452619] create index id
x_1 on tab_test_1(id);452585 | {452619}   | waiting | Lock:relation     | 00:00:07 | 00:00:07 | 1       | 2,147,483,645 | postgres | postgres |    0 |  [452585] . vacuum full t
ab_test_1 ;
(2 rows)//阻塞analyzepid   | blocked_by |  state  |       wait        | wait_age |  tx_age  | xid_age |   xmin_ttf    | datname  | usename  | blkd |                      quer
y
--------+------------+---------+-------------------+----------+----------+---------+---------------+----------+----------+------+--------------------------
-----------------------452619 | {}         | idletx  | Client:ClientRead |          | 00:14:04 | 2       |               | postgres | postgres |    1 |  [452619] create index id
x_1 on tab_test_1(id);452585 | {452619}   | waiting | Lock:relation     | 00:00:07 | 00:00:07 |         | 2,147,483,645 | postgres | postgres |    0 |  [452585] . analyze tab_t
est_1;
(2 rows)

1.6 创建普通B-tree索引的可能遇到的问题

问题：

​ 创建普通B-tree索引在表上申请的是ShareLock，ShareLock和RowExclusiveLock是冲突的，所以create index会等待表上所有的DML（增删改）结束。但是实际在生产环境下，如果业务不停运行，涉及到要加索引的表不停的有DML操作，那么，执行了create index操作后，可能会发现长时间都没有反应，因为create index操作可能长时间获取不到锁，然后一直处于锁的等待队列里。

​ 就算能获取到了锁，可以创建索引了，但是在创建索引期间，也会阻塞所有的DML（增删改），如果需要加索引的表是一个大表，并且需要加索引的这列数据也比较复杂，那么可能执行时间比较长，那么对DML的阻塞时间也会比较长，这对于某些业务场景可能是不能接受的。除了阻塞时间长一个问题外，如果建索引期间，业务较多，被阻塞的DML大量累积，有可能导致pg_locks里累积的越来越多，最后导致OOM。

解决方法：

（1）对于建索引的操作尽量选择业务量较少的时候执行，或者有条件在停业务的窗口内完成。

（2）设置lock_timeout，不让其长时间的获取锁，阻塞业务。

（3）可以使用create index concurrently 在线创建索引(CIC)，降低了创建索引在表上申请的锁的级别，ShareUpdateExclusiveLock级别的锁和RowExclusiveLock不冲突，不会阻塞DML操作。

创建索引慢：
至于常见的创建索引慢的原因也可以参考我的这篇文章常见的创建索引慢的原因

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/608632.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

java 体育明星管理系统Myeclipse开发mysql数据库web结构java编程计算机网页项目

java 体育明星管理系统Myeclipse开发mysql数据库web结构java编程计算机网页项目

一、源码特点 java Web 体育明星管理系统是一套完善的java web信息管理系统，对理解JSP java编程开发语言有帮助，系统具有完整的源代码和数据库，系统主要采用B/S模式开发。开发环境为 TOMCAT7.0,Myeclipse8.5开发，数据库为Mysq…
阅读更多...
Clojure 实战(4)：编写 Hadoop MapReduce 脚本

Clojure 实战(4)：编写 Hadoop MapReduce 脚本

Hadoop简介 众所周知，我们已经进入了大数据时代，每天都有PB级的数据需要处理、分析，从中提取出有用的信息。Hadoop就是这一时代背景下的产物。它是Apache基金会下的开源项目，受Google两篇论文的启发，采用分布式的文件…
阅读更多...
Spark Core--加强

Spark Core--加强

RDD的持久化 RDD缓存 当RDD被重复使用，或者计算该RDD比较容易出错，而且需要消耗比较多的资源和时间的时候，我们就可以将该RDD缓存起来。 主要作用: 提升Spark程序的计算效率 注意事项: RDD的缓存可以存储在内存或者是磁盘上，甚至…
阅读更多...
【数据结构】二叉树链式结构详解

【数据结构】二叉树链式结构详解

目录 1.前言2.快速创建一颗二叉树3.二叉树的遍历3.1前序遍历3.2中序遍历3.3后序遍历3.4层序遍历 4.二叉树节点个数与高度4.1二叉树节点个数4.2二叉树叶子节点个数4.3二叉树高度4.4二叉树第k层节点个数4.5二叉树查找值为x的节点 5.二叉树的基础oj题练习6.二叉树的创建和销毁6.1通…
阅读更多...
JVM，JRE，JDK的区别和联系简洁版

JVM，JRE，JDK的区别和联系简洁版

先看图 利用JDK（调用JAVA API）开发JAVA程序后，通过JDK中的编译程序（javac）将我们的文本java文件编译成JAVA字节码，在JRE上运行这些JAVA字节码，JVM解析这些字节码，映射到CPU指令集或…
阅读更多...
Spring学习 基于注解的AOP配置

Spring学习 基于注解的AOP配置

5.1.创建工程 5.1.1.pom.xml <?xml version"1.0" encoding"UTF-8"?> <project xmlns"http://maven.apache.org/POM/4.0.0"xmlns:xsi"http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation"http://maven.ap…
阅读更多...
springCould中的Config-从小白开始【10 】

springCould中的Config-从小白开始【10 】

目录 &#x1f32d;1.spring cloud Config是什么&#x1f636;‍&#x1f32b;️&#x1f636;‍&#x1f32b;️&#x1f636;‍&#x1f32b;️ &#x1f953;2.能干什么&#x1f636;‍&#x1f32b;️&#x1f636;‍&#x1f32b;️&#x1f636;‍&#x1f32b;️ &am…
阅读更多...
SSH远程访问出现Permission denied(password)解决方法

SSH远程访问出现Permission denied(password)解决方法

首先&#xff0c;这个不是密码输错了的问题&#xff1b; 1、在主机先ping一下服务器 ping XXX.XXX.XX.XXX (服务器ip地址) 如果pin成功了&#xff0c;说明可以进行连接 查看服务器的ip ifconfig2、主机连接服务器 &#xff08;服务器的ip&#xff09; ssh testXXX.XXX.XX.…
阅读更多...
LeetCode-数组-双指针-中等难度

LeetCode-数组-双指针-中等难度

文章目录 双指针1. 删除有序数组中的重复项&#xff08;入门&#xff09;1.1 题目描述1.2 解题思路1.3 代码实现 2. 删除有序数组中的重复项 II&#xff08;简单&#xff09;2.1 题目描述2.2 解题思路2.3 代码实现 3. 移动零&#xff08;简单&#xff09;3.1 题目描述3.2 代码实…
阅读更多...
AQS应用之BlockingQueue详解

AQS应用之BlockingQueue详解

概要 AQS全称是 AbstractQueuedSynchronizer&#xff0c;中文译为抽象队列式同步器。BlockingQueue&#xff0c;是java.util.concurrent 包提供的用于解决并发生产者 - 消费者问题的最有用的类&#xff0c;它的特性是在任意时刻只有一个线程可以进行take或者put操作&#xff0…
阅读更多...
MySQL之导入导出远程备份

MySQL之导入导出远程备份

目录 一. navicat导入导出 二. mysqldump命令导入导出 导入 导出 三. load data infile命令导入导出 导入 导出 四. 远程备份 导入 导出 思维导图 一. navicat导入导出 导入&#xff1a;右键➡运行SQL文件 导出&#xff1a;选中要导出的表➡右键➡转储SQL文件➡数据和结…
阅读更多...
C# Emgu.CV4.8.0读取rtsp流录制mp4可分段保存

C# Emgu.CV4.8.0读取rtsp流录制mp4可分段保存

【官方框架地址】 https://github.com/emgucv/emgucv 【算法介绍】 EMGU CV&#xff08;Emgu Computer Vision&#xff09;是一个开源的、基于.NET框架的计算机视觉库&#xff0c;它提供了对OpenCV&#xff08;开源计算机视觉库&#xff09;的封装。EMGU CV使得在.NET应用程序…
阅读更多...
x-cmd pkg | vhs - 将终端的操作过程录制成视频文件的终端录制工具

x-cmd pkg | vhs - 将终端的操作过程录制成视频文件的终端录制工具

目录 简介首次用户声明式录制脚本其他功能竞品和相关作品进一步阅读 简介 vhs 是一个命令行录制工具&#xff0c;用于将终端的操作过程录制成视频文件。是由 Charmbracelet 团队使用 Go 开发的&#xff0c;首个版本发布于 2022 年 10 月。开源不到一个月有接近 8k 的 star。 …
阅读更多...
Kubernetes (八) 金丝雀发布

Kubernetes (八) 金丝雀发布

一. 金丝雀发布作用&#xff1a; 金丝雀发布是指在生产环境中逐步推出新版本应用程序&#xff0c;只在一小部分用户或流量中使用该版本&#xff0c;并根据反馈逐步扩…
阅读更多...
Redis（三）持久化

Redis（三）持久化

文章目录 RDB&#xff08;Redis Database&#xff09;自动触发保存频率修改dump文件保存路径修改文件保存名称dump恢复 手动触发save![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/a56fdff44aee4efa96c2ce3615b69dc1.png)bgsave 优劣优点缺点 检查修复dump文件会触…
阅读更多...
手把手教你使用cubemx配置串口

手把手教你使用cubemx配置串口

重写fput函数 #include <stdio.h>#ifdef __GNUC__#define PUTCHAR_PROTOTYPE int _io_putchar(int ch)#else#define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)#endif /* __GNUC__*//*******************************************************************brief R…
阅读更多...
安全狗获评CCIA“2023年度先进会员单位”

安全狗获评CCIA“2023年度先进会员单位”

1月4日&#xff0c;2023年度中国网络安全产业联盟会员大会暨理事会在北京成功举办。 作为国内云原生安全领导厂商&#xff0c;安全狗也受邀出席此次活动。 厦门服云信息科技有限公司&#xff08;品牌名&#xff1a;安全狗&#xff09;创办于2013年&#xff0c;是国内领先的云…
阅读更多...
你的企业知识库该更新啦，这样搭建高效又轻松

你的企业知识库该更新啦，这样搭建高效又轻松

很明显&#xff0c;企业知识库已经成为我们工作中必不可少的资源&#xff0c;它的价值已经不言而喻&#xff0c;无论是促进团队合作&#xff0c;还是帮助我们更有效地找到收集和使用知识&#xff0c;知识库都发挥着重要的作用&#xff0c;然而&#xff0c;你的企业知识库已经过…
阅读更多...
springboot——消息中间件

springboot——消息中间件

消息的概念 从广义角度来说&#xff0c;消息其实就是信息&#xff0c;但是和信息又有所不同。信息通常被定义为一组数据&#xff0c;而消息除了具有数据的特征之外&#xff0c;还有消息的来源与接收的概念。通常发送消息的一方称为消息的生产者&#xff0c;接收消息的一方称为…
阅读更多...
OV5640 摄像头的图像平滑处理

OV5640 摄像头的图像平滑处理

如图所示&#xff0c;这是整个视频采集系统的原理框图。 上电初始&#xff0c;FPGA 需要通过 IIC 接口对 CMOS Sensor 进行寄存器初始化配置。这些初始化的基本参数&#xff0c;即初始化地址对应的初始化数据都存储在一个预先配置好的 FPGA 片内 ROM中。在初始化配置完成后&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023