PostgreSql 锁

一、概述

  在 PostgreSQL 事务中提到，多个用户访问相同数据时可能出现脏读，不可重复度，幻读，更新丢失的问题，为解决这些问题，定义了不同的隔离级别，而隔离级别的具体实现，依靠的就是数据库锁冲突的机制，在数据库中，不同事务在同一时刻不能对同一对象持有相互冲突的锁，PostgreSQL 提供了多种锁模式用于控制对表中数据的并发访问，大多数情况下数据库会在事务运行的过程中自动的给相关对象加锁解锁，以保证事物的正常运行及数据的一致性。

二、分类

2.1 表级锁

  两个事务在同一时刻不能在同一个表上持有相互冲突的锁，非冲突锁可以由许多事务同时持有。特别注意，一个事务决不会和自身冲突，例如，它可以在同一个表上获得 ACCESS EXCLUSIVE 锁然后接着获取 ACCESS SHARE 锁。表级锁冲突矩阵如下，空白表示两种锁可相互兼容，X 表示两种锁相互冲突。
在这里插入图片描述

  • ACCESS SHARE：只与 ACCESS EXCLUSIVE 锁模式冲突。SELECT 命令在被引用的表上获得一个这种模式的锁。通常，任何只读取表而不修改它的查询都将获得这种模式的锁。
  • ROW SHARE：与 EXCLUSIVE 和 ACCESS EXCLUSIVE 锁模式冲突。SELECT FOR UPDATE 和SELECT FOR SHARE 命令在目标表上取得一个这种模式的锁。
  • ROW EXCLUSIVE：与 SHARE、SHARE ROW EXCLUSIVE、EXCLUSIVE 和 ACCESS EXCLUSIVE 锁模式冲突。命令 UPDATE、DELETE 和 INSERT 在目标表上取得这种锁模式。通常，这种锁模式将被任何修改表中数据的命令取得。
  • SHARE UPDATE EXCLUSIVE：与 SHARE UPDATE EXCLUSIVE、SHARE、SHARE ROW EXCLUSIVE、EXCLUSIVE 和 ACCESS EXCLUSIVE 锁模式冲突。这种模式保护一个表不受并发模式改变和 VACUUM 运行的影响。VACUUM（不带FULL）、ANALYZE、 CREATE INDEX CONCURRENTLY、REINDEX CONCURRENTLY、 CREATE STATISTICS 以及某些 ALTER INDEX 和 ALTER TABLE 的变体获得这种模式的锁。
  • SHARE：与 ROW EXCLUSIVE、SHARE UPDATE EXCLUSIVE、SHARE ROW EXCLUSIVE、EXCLUSIVE 和 ACCESS EXCLUSIVE 锁模式冲突。这种模式保护一个表不受并发数据改变的影响。CREATE INDEX（不带 CONCURRENTLY）将获得这种模式的锁。
  • SHARE ROW EXCLUSIVE：与 ROW EXCLUSIVE、SHARE UPDATE EXCLUSIVE、SHARE、SHARE ROW EXCLUSIVE、EXCLUSIVE 和 ACCESS EXCLUSIVE 锁模式冲突。这种模式保护一个表不受并发数据修改所影响，并且是自排他的，这样在一个时刻只能有一个会话持有它。CREATE TRIGGER 和某些形式的 ALTER TABLE 将获得这种模式的锁。
  • EXCLUSIVE：与 ROW SHARE、ROW EXCLUSIVE、SHARE UPDATE EXCLUSIVE、SHARE、SHARE ROW EXCLUSIVE、EXCLUSIVE 和 ACCESS EXCLUSIVE 锁模式冲突。这种模式只允许并发的 ACCESS SHARE 锁，即只有来自于表的读操作可以与一个持有该锁模式的事务并行处理。REFRESH MATERIALIZED VIEW CONCURRENTLY 将获得这种模式的锁。
  • ACCESS EXCLUSIVE：与所有模式的锁冲突（ACCESS SHARE、ROW SHARE、ROW EXCLUSIVE、SHARE UPDATE EXCLUSIVE、SHARE、SHARE ROW EXCLUSIVE、EXCLUSIVE 和 ACCESS EXCLUSIVE）。这种模式保证持有者是访问该表的唯一事务。ALTER TABLE、DROP TABLE、TRUNCATE、REINDEX、CLUSTER、VACUUM FULL和REFRESH MATERIALIZED VIEW（不带CONCURRENTLY）命令将获得这种模式的锁。很多形式的 ALTER INDEX 和 ALTER TABLE 也在这个层面上获得锁。这也是未显式指定模式的 LOCK TABLE 命令的默认锁模式。

示例：
窗口 a 开启事务进行相关操作获取锁,窗口 b 查询当前持有的锁。

--窗口 a
postgres=# begin;
BEGIN--窗口 b
postgres=# select relation::regclass tab_name,mode from pg_locks where relation = 't'::regclass;tab_name | mode
----------+------
(0 rows)

上述可看到开启事务未进行任何操作时，未持锁。

--窗口 a
postgres=# begin;
BEGIN
postgres=*# select * from t;     -->新执行的操作a
---1
(1 row)--窗口 b
postgres=# select relation::regclass tab_name,mode from pg_locks where relation = 't'::regclass;tab_name |      mode
----------+-----------------t        | AccessShareLock       -->新增的锁
(1 row)

上述可看到事务中进行 select 操作时，持有了 ACCESS SHARE 锁。

--窗口 a
postgres=# begin;
BEGIN
postgres=*# select * from t;a
---1
(1 row)postgres=*# select * from t for update;     -->新执行的操作a
---1
(1 row)
--窗口 b
postgres=# select relation::regclass tab_name,mode from pg_locks where relation = 't'::regclass;tab_name |      mode
----------+-----------------t        | AccessShareLockt        | RowShareLock                    -->新增的锁
(2 rows)

上述可看到事务中进行 select for update 操作时，持有了 ROW SHARE 锁。

--窗口 a
postgres=# begin;
BEGIN
postgres=*# select * from t;a
---1
(1 row)postgres=*# select * from t for update;a
---1
(1 row)postgres=*# update t set a = 2 where a = 1;     -->新执行的操作
UPDATE 1
--窗口 b
postgres=# select relation::regclass tab_name,mode from pg_locks where relation = 't'::regclass;tab_name |       mode
----------+------------------t        | AccessShareLockt        | RowShareLockt        | RowExclusiveLock                    -->新增的锁
(3 rows)

上述可看到事务中进行 update 操作时，持有了 ROW EXCLUSIVE 锁。

--窗口 a
postgres=# begin;
BEGIN
postgres=*# select * from t;a
---1
(1 row)postgres=*# select * from t for update;a
---1
(1 row)postgres=*# update t set a = 2 where a = 1;     
UPDATE 1
postgres=*# create index idx_t_a on t(a);      -->新执行的操作
CREATE INDEX--窗口 b
postgres=# select relation::regclass tab_name,mode from pg_locks where relation = 't'::regclass;tab_name |       mode
----------+------------------t        | AccessShareLockt        | RowShareLockt        | RowExclusiveLockt        | ShareLock                          -->新增的锁
(4 rows)

上述可看到事务中进行 create index 操作时，持有了 SHARE 锁。

--窗口 a
postgres=# begin;
BEGIN
postgres=*# select * from t;a
---1
(1 row)postgres=*# select * from t for update;a
---1
(1 row)postgres=*# update t set a = 2 where a = 1;     
UPDATE 1
postgres=*# create index idx_t_a on t(a);      
CREATE INDEX
postgres=*# alter table t add b int;          -->新执行的操作
ALTER TABLE--窗口 b
postgres=# select relation::regclass tab_name,mode from pg_locks where relation = 't'::regclass;tab_name |       mode
----------+------------------t        | AccessShareLockt        | RowShareLockt        | RowExclusiveLockt        | ShareLockt        | AccessExclusiveLock                -->新增的锁
(5 rows)

上述可看到事务中进行 alter table 操作时，持有了 ACCESS EXCLUSIVE 锁。

2.2 行级锁

  除了表级锁以外，还有行级锁，两个事务不能在相同的行上持有冲突的锁（一个事务的不同子事务除外）。行级锁不影响数据查询，它们只阻塞对同一行的写入者和加锁者。行级锁在事务结束时或保存点回滚的时候释放，就像表级锁一样。行级锁冲突矩阵如下，空白表示两种锁可相互兼容，X 表示两种锁相互冲突。
在这里插入图片描述

  • FOR UPDATE：FOR UPDATE 会导致由 SELECT 语句检索到的行被锁定，就好像它们要被更新。这可以阻止它们被其他事务锁定、修改或者删除，一直到当前事务结束。也就是说其他尝试 UPDATE、DELETE、SELECT FOR UPDATE、SELECT FOR NO KEY UPDATE、SELECT FOR SHARE 或者 SELECT FOR KEY SHARE 将被阻塞，直到当前事务结束。反过来，SELECT FOR UPDATE 将等待已经在相同行上运行以上这些命令的并发事务，并且接着锁定并且返回被更新的行（或者没有行，因为行可能已被删除）。不过，在一个 REPEATABLE READ 或 SERIALIZABLE 事务中，如果一个要被锁定的行在事务开始后被更改，将会抛出一个错误。
  • FOR NO KEY UPDATE：行为与 FOR UPDATE 类似，不过获得的锁较弱，这种锁将不会阻塞尝试在相同行上获得锁的 SELECT FOR KEY SHARE 命令。任何不获取 FOR UPDATE 锁的 UPDATE 也会获得这种锁模式。
  • FOR SHARE：行为与 FOR NO KEY UPDATE 类似，不过它在每个检索到的行上获得一个共享锁而不是排他锁。一个共享锁会阻塞其他事务在这些行上执行 UPDATE、DELETE、SELECT FOR UPDATE 或者 SELECT FOR NO KEY UPDATE，但是它不会阻止它们执行 SELECT FOR SHARE 或者 SELECT FOR KEY SHARE。
  • FOR KEY SHARE：行为与 FOR SHARE 类似，不过锁较弱，SELECT FOR UPDATE 会被阻塞，但是 SELECT FOR NO KEY UPDATE 不会被阻塞。一个键共享锁会阻塞其他事务执行修改键值的 DELETE 或者 UPDATE，但不会阻塞其他 UPDATE，也不会阻止 SELECT FOR NO KEY UPDATE、SELECT FOR SHARE或者 SELECT FOR KEY SHARE。

示例：
窗口 a 在事务中执行操作，窗口 b 对同一对象执行操作，查看是否冲突。

--窗口 a
postgres=# begin;
BEGIN
postgres=*# select * from t for update;a
---1
(1 row)--窗口 b
postgres=# select * from t for update;
^CCancel request sent
ERROR:  canceling statement due to user request
CONTEXT:  while locking tuple (0,1) in relation "t"
postgres=# select * from t for no key update;
^CCancel request sent
ERROR:  canceling statement due to user request
CONTEXT:  while locking tuple (0,1) in relation "t"
postgres=#
postgres=# select * from t for share;
^CCancel request sent
ERROR:  canceling statement due to user request
CONTEXT:  while locking tuple (0,1) in relation "t"
postgres=#
postgres=# select * from t for key share;
^CCancel request sent
ERROR:  canceling statement due to user request
CONTEXT:  while locking tuple (0,1) in relation "t"

上述可看到 for update 行锁同其他所有行锁冲突。

--窗口 a
postgres=# begin;
BEGIN
postgres=*# select * from t for key share;a
---1
(1 row)--窗口 b
postgres=# select * from t for update;
^CCancel request sent
ERROR:  canceling statement due to user request
CONTEXT:  while locking tuple (0,1) in relation "t"
postgres=#
postgres=# select * from t for no key update;a
---1
(1 row)postgres=# select * from t for share;a
---1
(1 row)postgres=# select * from t for key share;a
---1
(1 row)

上述可看到 for key share 行锁仅同 for update 行锁冲突。

2.3 页级锁

  除了表级别和行级别的锁以外，页面级别的共享/排他锁被用来控制对共享缓冲池中表页面的读/写。 这些锁在行被抓取或者更新后马上被释放。应用开发者通常不需要关心页级锁，我们在这里提到它们只是为了完整。

2.4 死锁

  显式锁定的使用可能会增加死锁的可能性，死锁是指两个（或多个）事务相互持有对方想要的锁。例如，如果事务 1 在表 A 上获得一个排他锁，同时试图获取一个在表 B 上的排他锁， 而事务 2 已经持有表 B 的排他锁，同时却正在请求表 A 上的一个排他锁，那么两个事务就都不能进行下去。PostgreSQL 能够自动检测到死锁情况并且会通过中断其中一个事务从而允许其它事务完成来解决这个问题（具体哪个事务会被中断是很难预测的，而且也不应该依靠这样的预测）。防止死锁的最好方法通常是保证所有使用一个数据库的应用都以一致的顺序在多个对象上获得锁。
示例：

--窗口 a
postgres=# begin;
BEGIN
postgres=*# update t1 set a = 2 where a = 1;
UPDATE 1
postgres=*# update t2 set a = 11 where a = 1;
UPDATE 1--窗口 b
postgres=# begin;
BEGIN
postgres=*# update t2 set a = 2 where a = 1;
UPDATE 1
postgres=*# update t1 set a = 22 where a = 1;
ERROR:  deadlock detected            -->此处触发了死锁自动处理机制，中断了该事务。
DETAIL:  Process 11771 waits for ShareLock on transaction 231938; blocked by process 11547.
Process 11547 waits for ShareLock on transaction 231940; blocked by process 11771.
HINT:  See server log for query details.
CONTEXT:  while updating tuple (0,4) in relation "t1"

2.5 咨询锁

  PostgreSQL 提供了一种方法创建由应用定义其含义的锁。这种锁被称为咨询锁，因为系统并不强迫其使用而是由应用来保证其正确的使用。咨询锁可用于 MVCC 模型不适用的锁定策略，其上限数量由 max_locks_per_transaction 和 max_connections 变量决定。
有两种方法在 PostgreSQL 中获取一个咨询锁：
会话级别：对于每一个完成的锁请求必须有一个相应的解锁请求，直至锁被真正释放。
事务级别：在事务结束时会自动释放它们，并且没有显式的解锁操作。

操作咨询锁的函数：
在这里插入图片描述
在这里插入图片描述

示例：
两个窗口同时对一条数据执行删除插入操作时会存在如下问题：

--窗口 a
postgres=# create table t1(id int primary key);
CREATE TABLE
postgres=#
postgres=# insert into t1 values(1);
INSERT 0 1
postgres=#
postgres=# begin;
BEGIN
postgres=*# delete from t1 where id = 1;
DELETE 1
postgres=*# insert into t1 values(1);
INSERT 0 1
postgres=*#--窗口 b
postgres=# begin;
BEGIN
postgres=*# delete from t1 where id = 1;DELETE 0    -->窗口 a 事务未提交之前一直等待，窗口 a 事务提交后，显示删除 0 行。
postgres=*# insert into t1 values(1);
ERROR:  duplicate key value violates unique constraint "t1_pkey"
DETAIL:  Key (id)=(1) already exists.   -->插入数据报主键唯一约束错误。

上述情况，就可通过使用咨询锁避免:

--窗口 a
postgres=# begin;
BEGIN
postgres=*# select pg_try_advisory_xact_lock(1);  -->窗口 a 进行操作前获取咨询锁pg_try_advisory_xact_lock
---------------------------t
(1 row)postgres=*# delete from t1 where id =1;
DELETE 1
postgres=*# insert into t1 values(1);
INSERT 0 1
postgres=*# commit;
COMMIT--窗口 b
postgres=# begin;
BEGIN
postgres=*# select pg_try_advisory_xact_lock(1);   --窗口 b 进行操作前获取咨询锁失败,不能进行下一步操作。pg_try_advisory_xact_lock
---------------------------f
(1 row)postgres=*# select pg_try_advisory_xact_lock(1);   --窗口 b 在窗口 a 提交事务后获取咨询锁成功，可进行下一步操作。pg_try_advisory_xact_lock
---------------------------t
(1 row)postgres=*# delete from t1 where id =1;
DELETE 1
postgres=*# insert into t1 values(1);
INSERT 0 1
postgres=*# commit;
COMMIT
postgres=# select * from t1;id
----1
(1 row)

三、LOCK 显示锁定

3.1 语法

LOCK [ TABLE ] [ ONLY ] name [ * ] [, ...] [ IN lockmode MODE ] [ NOWAIT ]其中 lockmode 可以是以下之一：ACCESS SHARE | ROW SHARE | ROW EXCLUSIVE | SHARE UPDATE EXCLUSIVE| SHARE | SHARE ROW EXCLUSIVE | EXCLUSIVE | ACCESS EXCLUSIVE

参数说明：

name：要锁定的一个现有表的名称（可以是模式限定的）。如果在表名前指定了 ONLY，只有该表会被锁定。如果没有指定了 ONLY，该表和它所有的后代表（如果有）都会被锁定。可选地，在表名后指定 * 来显式地表示把后代表包括在内。命令LOCK TABLE a, b 等效于 LOCK TABLE a; LOCK TABLE b。这些表会被按照在 LOCK TABLE中指定的顺序一个一个被锁定。
lockmode：锁模式指定这个锁和哪些锁冲突。如果没有指定锁模式，那将使用最严格的模式 ACCESS EXCLUSIVE。
NOWAIT：指定 LOCK TABLE 不等待任何冲突锁被释放：如果所指定的锁不能立即获得，那么事务就会中止。

3.2 示例

--在将要执行一次删除操作前在主键表上取一个 SHARE ROW EXCLUSIVE 锁
BEGIN WORK;
LOCK TABLE films IN SHARE ROW EXCLUSIVE MODE;
DELETE FROM films_user_comments WHERE id IN(SELECT id FROM films WHERE rating < 5);
DELETE FROM films WHERE rating < 5;
COMMIT WORK;

四、锁问题处理

4.1 排查

--查询持锁
SELECT
lock2.pid as locking_pid,
lock1.pid as locked_pid,
stat1.usename as locked_user,
stat1.query as locked_statement,
stat1.state as state,
stat2.query as locking_statement,
stat2.state as state,
now() - stat1.query_start as locking_duration,
stat2.usename as locking_user
FROM pg_catalog.pg_locks lock1
JOIN pg_catalog.pg_stat_activity stat1 on lock1.pid = stat1.pid
JOIN pg_catalog.pg_locks lock2 on
(lock1.locktype,lock1.database,lock1.relation,
lock1.page,lock1.tuple,lock1.virtualxid,
lock1.transactionid,lock1.classid,lock1.objid,
lock1.objsubid) IS NOT DISTINCT FROM
(lock2.locktype,lock2.DATABASE,
lock2.relation,lock2.page,
lock2.tuple,lock2.virtualxid,
lock2.transactionid,lock2.classid,
lock2.objid,lock2.objsubid)
JOIN pg_catalog.pg_stat_activity stat2 on lock2.pid
= stat2.pid
WHERE NOT lock1.granted AND lock2.granted;--查询行锁
with    
t_wait as    
(    select a.mode,a.locktype,a.database,a.relation,a.page,a.tuple,a.classid,a.granted,   a.objid,a.objsubid,a.pid,a.virtualtransaction,a.virtualxid,a.transactionid,a.fastpath,    b.state,b.query,b.xact_start,b.query_start,b.usename,b.datname,b.client_addr,b.client_port,b.application_name   from pg_locks a,pg_stat_activity b where a.pid=b.pid and not a.granted   
),   
t_run as   
(   select a.mode,a.locktype,a.database,a.relation,a.page,a.tuple,a.classid,a.granted,   a.objid,a.objsubid,a.pid,a.virtualtransaction,a.virtualxid,a.transactionid,a.fastpath,   b.state,b.query,b.xact_start,b.query_start,b.usename,b.datname,b.client_addr,b.client_port,b.application_name   from pg_locks a,pg_stat_activity b where a.pid=b.pid and a.granted   
),   
t_overlap as   
(   select r.* from t_wait w join t_run r on   (   r.locktype is not distinct from w.locktype and   r.database is not distinct from w.database and   r.relation is not distinct from w.relation and   r.page is not distinct from w.page and   r.tuple is not distinct from w.tuple and   r.virtualxid is not distinct from w.virtualxid and   r.transactionid is not distinct from w.transactionid and   r.classid is not distinct from w.classid and   r.objid is not distinct from w.objid and   r.objsubid is not distinct from w.objsubid and   r.pid <> w.pid   )    
),    
t_unionall as    
(    select r.* from t_overlap r    union all    select w.* from t_wait w    
)    
select locktype,datname,relation::regclass,page,tuple,virtualxid,transactionid::text,classid::regclass,objid,objsubid,   
string_agg(   
'Pid: '||case when pid is null then 'NULL' else pid::text end||chr(10)||   
'Lock_Granted: '||case when granted is null then 'NULL' else granted::text end||' , Mode: '||case when mode is null then 'NULL' else mode::text end||' , FastPath: '||case when fastpath is null then 'NULL' else fastpath::text end||' , VirtualTransaction: '||case when virtualtransaction is null then 'NULL' else virtualtransaction::text end||' , Session_State: '||case when state is null then 'NULL' else state::text end||chr(10)||   
'Username: '||case when usename is null then 'NULL' else usename::text end||' , Database: '||case when datname is null then 'NULL' else datname::text end||' , Client_Addr: '||case when client_addr is null then 'NULL' else client_addr::text end||' , Client_Port: '||case when client_port is null then 'NULL' else client_port::text end||' , Application_Name: '||case when application_name is null then 'NULL' else application_name::text end||chr(10)||    
'Xact_Start: '||case when xact_start is null then 'NULL' else xact_start::text end||' , Query_Start: '||case when query_start is null then 'NULL' else query_start::text end||' , Xact_Elapse: '||case when (now()-xact_start) is null then 'NULL' else (now()-xact_start)::text end||' , Query_Elapse: '||case when (now()-query_start) is null then 'NULL' else (now()-query_start)::text end||chr(10)||    
'SQL (Current SQL in Transaction): '||chr(10)||  
case when query is null then 'NULL' else query::text end,    
chr(10)||'--------'||chr(10)    
order by    ( case mode    when 'INVALID' then 0   when 'AccessShareLock' then 1   when 'RowShareLock' then 2   when 'RowExclusiveLock' then 3   when 'ShareUpdateExclusiveLock' then 4   when 'ShareLock' then 5   when 'ShareRowExclusiveLock' then 6   when 'ExclusiveLock' then 7   when 'AccessExclusiveLock' then 8   else 0   end ) desc,   (case when granted then 0 else 1 end)  
) as lock_conflict  
from t_unionall   
group by   
locktype,datname,relation,page,tuple,virtualxid,transactionid::text,classid,objid,objsubid;--查询超过 5s 的长事务
select        usename,datname,state,wait_event_type,wait_event,xact_start,now(),query,pid,now()-xact_start as time
from pg_stat_activity 
where now()-xact_start>interval '5 sec' and query !~ '^COPY' and state<>'idle' 
order by xact_start;

4.2 解锁

--session消失，事物回退，需要superuser权限，可以关闭所有的后台进程
select pg_terminate_backend(1445);--session还在，事物回退，只能关闭自己用户下的后台进程     
select pg_cancel_backend(1445);         --批量取消生成取消的SQL
WITH trans AS(SELECT pidFROM pg_stat_activityWHERE now()-xact_start>interval '10 sec'AND query !~ '^COPY'AND STATE<>'idle'ORDER BY xact_start)
SELECT 'select pg_cancel_backend' || '(' || trans.pid || ');'AS killsql
FROM trans;WITH trans AS  (SELECT pidFROM pg_stat_activityWHERE now()-xact_start>interval '10 sec'AND query !~ '^COPY'AND STATE<>'idle'ORDER BY xact_start)
SELECT 'select pg_terminate_backend' || '(' || trans.pid || ');'AS killsql
FROM trans;

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

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

相关文章

钉钉群消息推送

钉钉群消息推送

1. 添加钉钉群机器人 PC端登录&#xff08;当前版本手机端无法进行推送关键词设置&#xff09;&#xff0c;群设置--> 机器人 --> webhook进行安全设置复制webhook对应的url 2. 群消息推送 钉钉群消息支持纯文本和markdown类型 2.1 调用示例源码 import com.alibaba.…
阅读更多...
助你丝滑过度到 Vue3 组合式Api的优势新的组件 ②⑧

助你丝滑过度到 Vue3 组合式Api的优势新的组件 ②⑧

作者 : SYFStrive 博客首页 : HomePage &#x1f4dc;&#xff1a; VUE3~TS &#x1f4cc;&#xff1a;个人社区&#xff08;欢迎大佬们加入&#xff09; &#x1f449;&#xff1a;社区链接&#x1f517; &#x1f4cc;&#xff1a;觉得文章不错可以点点关注 &#x1f449;…
阅读更多...
2023.08.01 驱动开发day8

2023.08.01 驱动开发day8

驱动层 #include <linux/init.h> #include <linux/module.h> #include <linux/of.h> #include <linux/of_irq.h> #include <linux/interrupt.h> #include <linux/fs.h> #include <linux/gpio.h> #include <linux/of_gpio.h>#…
阅读更多...
如何在免费版 pycharm 中使用 github copilot (chatGPT)？

如何在免费版 pycharm 中使用 github copilot (chatGPT)？

起因 在 vscode 中使用了 github copilot 以后&#xff0c;感觉这个人工智能还不错。 但 vscode 对于 python 项目调试并不是特别方便&#xff0c;所以想在 Pycharm 中也能使用同一个 github 账号&#xff0c;用上 copilot 的功能。 不需要等待&#xff0c;安装即用&#xff…
阅读更多...
【Web 表单】与用户数据打交道-1(mdn笔记)

【Web 表单】与用户数据打交道-1(mdn笔记)

0. Web 表单指南 我们将介绍 Web 表单的各个方面&#xff1a;HTML 结构、样式、验证表单数据&#xff0c;以及提交数据到服务器。 基本指南 你的第一个表单 第一次创建 HTML 表单的经验&#xff0c;包括设计一个简单表单、使用正确的 HTML 元素实现它、通过 CSS 添加一些非常简…
阅读更多...
【Spring Cloud一】微服务基本知识

【Spring Cloud一】微服务基本知识

系列文章目录 微服务基本知识 系列文章目录前言一、系统架构的演变1.1单体架构1.2分层架构1.3分布式架构1.4微服务架构1.5分布式、SOA、微服务的异同点 二、CAP原则三、RESTfulRESTful的核心概念&#xff1a; 四、共识算法 前言 在实际项目开发过程中&#xff0c;目前负责开发…
阅读更多...
Spring?Boot项目如何优雅实现Excel导入与导出功能

Spring?Boot项目如何优雅实现Excel导入与导出功能

目录 背景EasyExcel 问题分析与解决Spring Boot Excel 导入与导出 依赖引入Excel 导入 基本导入功能进阶导入功能Excel 导出 Excel 导入参数校验 开启校验 校验规则定义 Bean Validation 定义校验规则ExcelValidator 接口定义校验规则校验结果接收 异常捕获接收校验结果contro…
阅读更多...
小研究 - 主动式微服务细粒度弹性缩放算法研究（三）

小研究 - 主动式微服务细粒度弹性缩放算法研究（三）

微服务架构已成为云数据中心的基本服务架构。但目前关于微服务系统弹性缩放的研究大多是基于服务或实例级别的水平缩放&#xff0c;忽略了能够充分利用单台服务器资源的细粒度垂直缩放&#xff0c;从而导致资源浪费。为此&#xff0c;本文设计了主动式微服务细粒度弹性缩放算法…
阅读更多...
使用 Go 语言实现二叉搜索树

使用 Go 语言实现二叉搜索树

原文链接&#xff1a; 使用 Go 语言实现二叉搜索树 二叉树是一种常见并且非常重要的数据结构&#xff0c;在很多项目中都能看到二叉树的身影。 它有很多变种&#xff0c;比如红黑树&#xff0c;常被用作 std::map 和 std::set 的底层实现&#xff1b;B 树和 B 树&#xff0c;…
阅读更多...
Total Variation loss

Total Variation loss

Total Variation loss 适合任务 图像复原、去噪等 处理的问题 图像上的一点点噪声可能就会对复原的结果产生非常大的影响&#xff0c;很多复原算法都会放大噪声。因此需要在最优化问题的模型中添加一些正则项来保持图像的光滑性&#xff0c;图片中相邻像素值的差异可以通过…
阅读更多...
传统计算机视觉

传统计算机视觉

传统计算机视觉 计算机视觉难点图像分割基于主动轮廓的图像分割基于水平集的图像分割交互式图像分割基于模型的运动分割 目标跟踪基于光流的点目标跟踪基于均值漂移的块目标跟踪基于粒子滤波的目标跟踪基于核相关滤波的目标跟踪 目标检测一般目标检测识别之特征一般目标检测识别…
阅读更多...
18.Netty源码之ByteBuf 详解

18.Netty源码之ByteBuf 详解

highlight: arduino-light ByteBuf 是 Netty 的数据容器&#xff0c;所有网络通信中字节流的传输都是通过 ByteBuf 完成的。 然而 JDK NIO 包中已经提供了类似的 ByteBuffer 类&#xff0c;为什么 Netty 还要去重复造轮子呢&#xff1f;本节课我会详细地讲解 ByteBuf。 JDK NIO…
阅读更多...
Spring学习记录----十五、面向切面编程AOP+十六、Spring对事务的支持

Spring学习记录----十五、面向切面编程AOP+十六、Spring对事务的支持

目录 十五、面向切面编程AOP 15.1 AOP介绍 总结 15.2 AOP的七大术语 15.3 切点表达式 15.4 使用Spring的AOP 15.4.1 准备工作 15.4.1.1Spring AOP 基于注解之实现步骤 15.4.1.2-Spring AOP 基于注解之切点表达式 代码 运行结果&#xff1a; 代码 运行结果 通知类…
阅读更多...
Python高阶技巧 递归

Python高阶技巧 递归

递归的定义 函数作为一种代码封装&#xff0c;可以被其他程序调用&#xff0c;当然&#xff0c;也可以被函数内部代码调用。这种函数定义中调用函数自身的方式称为递归。 递归的思想 把规模大的问题转化为规模小的、具有与原来问题相同解法的问题来解决。在函数实现时&#…
阅读更多...
SpringBoot集成Thymeleaf

SpringBoot集成Thymeleaf

Spring Boot 集成 Thymeleaf 模板引擎 1、Thymeleaf 介绍 Thymeleaf 是适用于 Web 和独立环境的现代服务器端 Java 模板引擎。 Thymeleaf 的主要目标是为开发工作流程带来优雅的自然模板&#xff0c;既可以在浏览器中正确显示的 HTML&#xff0c;也可以用作静态原型&#xf…
阅读更多...
C#+WPF上位机开发（模块化+反应式）

C#+WPF上位机开发（模块化+反应式）

在上位机开发领域中&#xff0c;C#与C两种语言是应用最多的两种开发语言&#xff0c;在C语言中&#xff0c;与之搭配的前端框架通常以QT最为常用&#xff0c;而C#语言中&#xff0c;与之搭配的前端框架是Winform和WPF两种框架。今天我们主要讨论一下C#和WPF这一对组合在上位机开…
阅读更多...
css图标 | 来自 fontawesome 字体文件的586 个小图标

css图标 | 来自 fontawesome 字体文件的586 个小图标

1. css效果 /*!* Font Awesome 4.4.0 by davegandy - http://fontawesome.io - fontawesome* License - http://fontawesome.io/license (Font: SIL OFL 1.1, CSS: MIT License)*/.fa-glass:before {content:"\f000"} .fa-music:before {content:"\f001"…
阅读更多...
小白如何理解MySQL？一文吃透

小白如何理解MySQL？一文吃透

从本质上来说&#xff0c;MySQL也是一个软件&#xff0c;以Java为例&#xff0c;Java通过JDBC进行MySQL驱动连接后&#xff0c;通过调用“MySQL”的“接口”将SQL语句传给MySQL&#xff0c;并获取返回结果&#xff01; 连接器 第一步&#xff0c;你会先连接到这个数据库上&…
阅读更多...
项目管理：项目计划有哪些不可忽视的作用

项目管理：项目计划有哪些不可忽视的作用

为了确保项目在我们的预期范围内完成&#xff0c;编制计划是不可或缺的&#xff0c;它可以帮助项目管理团队进行提前思考、识别和管理任何疏漏和风险。 项目计划进行跟踪中有哪些不可忽视的作用&#xff1a; 1、了解成员的工作情况 分配任务后&#xff0c;项目经理应主动与…
阅读更多...
蓝海卓越计费管理系统任意文件读取下载

蓝海卓越计费管理系统任意文件读取下载

看了大佬的文章&#xff0c;太牛逼啦&#xff0c;下面是大佬文章原文。 蓝海卓越计费管理系统任意文件读取下载 鹰图语法&#xff1a;web.title"蓝海卓越计费管理系统" 访问url 直接更改url就行了 /download.php?file../../../../../etc/passwd
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023