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.rhkb.cn/news/74253.html

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

相关文章

开放自动化软件的硬件平台

开放自动化软件的硬件平台

自动化行业的产品主要以嵌入式系统为主&#xff0c;历来对产品硬件的可靠性和性能都提出很高的要求。最典型的产品要数PLC。PLC 要求满足体积小&#xff0c;实时性&#xff0c;可靠性&#xff0c;可扩展性强&#xff0c;环境要求高等特点。它们通常采用工业级高性能嵌入式SoC 实…
阅读更多...
Django Rest_Framework（一）

Django Rest_Framework（一）

1. Web应用模式 在开发Web应用中&#xff0c;有两种应用模式&#xff1a; 前后端不分离[客户端看到的内容和所有界面效果都是由服务端提供出来的。] 前后端分离【把前端的界面效果(html&#xff0c;css&#xff0c;js分离到另一个服务端或另一个目录下&#xff0c;python服务…
阅读更多...
使用 github 同步谷歌浏览器书签

使用 github 同步谷歌浏览器书签

想必使用谷歌浏览器Chrome的用户一定非常头疼的一件事就是&#xff1a;账户不能登录&#xff0c;书签收藏夹不能同步&#xff0c;换一台电脑书签收藏夹没有了&#xff01; 下面教大家一招亲测有效适用的方法解决书签同步问题&#xff0c;在任何电脑都可以同步了 1、去下载谷歌…
阅读更多...
从零开始学Docker（三）：DockerFile镜像定制

从零开始学Docker（三）：DockerFile镜像定制

宿主机环境&#xff1a;RockyLinux 9 前言&#xff0c;定制docker镜像的方式有两种&#xff1a; 手动修改容器内容&#xff0c;然后docker commit提交容器为新的镜像通过在dockerfile中定义一系列的命令和参数构成的脚本&#xff0c;然后这些命令应用于基础镜像&#xff0c;依…
阅读更多...
websocket服务端大报文发送连接自动断开分析

websocket服务端大报文发送连接自动断开分析

概述 当前springboot版本&#xff1a;2.7.4 使用依赖 <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-websocket</artifactId> </dependency>现象概述&#xff1a; 客户端和服务端已经有心跳…
阅读更多...
iframe跨域解决方案

iframe跨域解决方案

在 Web 开发中&#xff0c;跨域是指在一个域&#xff08;例如&#xff0c;https://www.example.com&#xff09;的页面中请求了另一个域&#xff08;例如&#xff0c;https://api.example.com&#xff09;的资源&#xff0c;浏览器出于安全考虑会阻止这样的请求。为了解决 ifra…
阅读更多...
Jmeter如何添加插件

Jmeter如何添加插件

一、前言 ​ 在我们的工作中&#xff0c;我们可以利用一些插件来帮助我们更好的进行性能测试。今天我们来介绍下Jmeter怎么添加插件&#xff1f; 2023最新Jmeter接口测试从入门到精通&#xff08;全套项目实战教程&#xff09; 二、插件管理器 ​ 首先我们需要下载插件管理器j…
阅读更多...
机器学习 | Python实现NARX模型预测控制

机器学习 | Python实现NARX模型预测控制

机器学习 | Python实现NARX模型预测控制 目录 机器学习 | Python实现NARX模型预测控制效果一览基本介绍研究内容程序设计参考资料效果一览 基本介绍 机器学习 | Python实现NARX模型预测控制 研究内容 贝叶斯黑盒模型预测控制，基于具有外源输入的非线性自回归模型的预期自由能最…
阅读更多...
地址空间细致入微+深入了解页表

地址空间细致入微+深入了解页表

目录 地址空间保存了什么&#xff1f; 页表到底是怎么存储的 我们都知道&#xff0c;我们进程看到的空间其实是虚拟内存&#xff0c;真正的内存是需要页表的映射才能找到真正的物理内存&#xff0c;那么我我们有两个问题的引出那么进程地址空间是保存了什么呢&#xff1f;页表…
阅读更多...
HCIP中期考试实验

HCIP中期考试实验

目录 考试需求 公司分部&#xff1a; 公司总部&#xff1a; 公司骨干网&#xff1a; 优化&#xff1a; 实验步骤&#xff1a; 步骤一&#xff1a;跟具题意配置IP地址&#xff0c;并创建拓扑 R1~R9配置 R10 &#xff1a;配置同时划分VLAN LSW4&#xff1a;划分VLAN交换…
阅读更多...
Android 面试题 虚拟机、进程、线程 七

Android 面试题 虚拟机、进程、线程 七

&#x1f525; 安卓虚拟机 &#x1f525; 虽然Android程序是使用Java语言开发的&#xff0c;当然&#xff0c;现在也可以使用kotlin语言。但是实际上我们开发出来的Android程序并不能运行在JVM上&#xff0c;而是只能运行在一个类似JVM的Android虚拟机上。Android虚拟机有两种&…
阅读更多...
Spring Boot 日志

Spring Boot 日志

Spring Boot 日志 ​ 在 Spring Boot 里面是有一个内置了的日志框架的&#xff0c;所以才能运行的时候在控制台打印出来。默认情况下的日志是系统定义和打印的&#xff0c;但我们也可以自行自定义打印日志。 日志的好处&#xff1a; 1、发现问题和定位问题&#xff1b;☆&am…
阅读更多...
QT编写的串口助手

QT编写的串口助手

QT编写的串口助手 提前的知识 创建UI界面工程 找帮助文档 添加串口的宏
阅读更多...
亚马逊品牌推荐金计划：通过亚马逊外营销活动赚取奖金！

亚马逊品牌推荐金计划：通过亚马逊外营销活动赚取奖金！

亚马逊美国站发布公告称新推出的品牌推荐金计划可以让卖家在通过亚马逊外营销活动的销售中获得奖金&#xff0c;当卖家将非亚马逊营销流量引导至亚马逊时&#xff0c;您将获得促销产品以及客户在接下来的两周内购买的任何品牌产品平均销售额的10%的奖金&#xff0c;以下是公告内…
阅读更多...
【NLP】训练chatglm2的评价指标BLEU，ROUGE

【NLP】训练chatglm2的评价指标BLEU，ROUGE

当进行一定程度的微调后&#xff0c;要评价模型输出的语句的准确性。由于衡量的对象是一个个的自然语言文本&#xff0c;所以通常会选择自然语言处理领域的相关评价指标。这些指标原先都是用来度量机器翻译结果质量的&#xff0c;并且被证明可以很好的反映待评测语句的准确性&a…
阅读更多...
ubuntu服务器配置ftp服务

ubuntu服务器配置ftp服务

需求&#xff1a;配置ftp服务用于在windows电脑上直接浏览、下载、上传ubuntu服务器上的文件&#xff0c;用于文件共享&#xff0c;方便实用 效果&#xff1a;用户打开windows资源管理器后输入ftp://xxx.xxx.xxx.xxx &#xff08;公网IP地址&#xff09;后&#xff0c;即可浏览…
阅读更多...
ChatGPT及其工作原理；OpenAI申请注册商标GPT-5，引发关注

ChatGPT及其工作原理；OpenAI申请注册商标GPT-5，引发关注

&#x1f989; AI新闻 &#x1f680; OpenAI申请注册商标GPT-5&#xff0c;引发关注 摘要&#xff1a;OpenAI已在上月18日申请注册商标GPT-5&#xff0c;显示该模型将提供文本生成、自然语言理解、语音转录、翻译、分析等功能。此前OpenAI曾表示尚未开始训练GPT-4的后继者GPT…
阅读更多...
Atlas200DK A2联网实战

Atlas200DK A2联网实战

文章目录 1.Atlas原始网络信息2. 开发板联网2.1 使用Type-c 连接开发板2.2 修改本地网络适配器2.3 修改开发板网络信息2.4 测试外网连接 1.Atlas原始网络信息 Type-C 网口 ETH0 网口 ETH1 网口 2. 开发板联网 2.1 使用Type-c 连接开发板 使用xshell 等ssh终端登录开发板&…
阅读更多...
(树) 剑指 Offer 33. 二叉搜索树的后序遍历序列 ——【Leetcode每日一题】

(树) 剑指 Offer 33. 二叉搜索树的后序遍历序列 ——【Leetcode每日一题】

❓剑指 Offer 33. 二叉搜索树的后序遍历序列 难度&#xff1a;中等 输入一个整数数组&#xff0c;判断该数组是不是某二叉搜索树的后序遍历结果。如果是则返回 true&#xff0c;否则返回 false。假设输入的数组的任意两个数字都互不相同。 参考以下这颗二叉搜索树&#xff1…
阅读更多...
Linux lvs负载均衡

Linux lvs负载均衡

LVS 介绍&#xff1a; Linux Virtual Server&#xff08;LVS&#xff09;是一个基于Linux内核的开源软件项目&#xff0c;用于构建高性能、高可用性的服务器群集。LVS通过将客户端请求分发到一组后端服务器上的不同节点来实现负载均衡&#xff0c;从而提高系统的可扩展性和可…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023