MySQL 事务的隔离级别及锁操作演示

最新推荐文章于 2024-09-26 14:19:34 发布
最新推荐文章于 2024-09-26 14:19:34 发布
阅读量27 收藏
点赞数
分类专栏： 后端码事 文章标签： mysql android 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012935445/article/details/132374840
版权
本文详细探讨了MySQL中的四种事务隔离级别：读未提交、读已提交、可重复读以及它们之间的区别。通过实例展示了在不同隔离级别下，如何处理脏读、不可重复读等问题。此外，还深入讲解了Next-Key锁的工作原理，包括等值条件和范围条件下的加锁行为，以及在实际操作中的锁冲突情况。
摘要由CSDN通过智能技术生成

MySQL 版本：5.7

安装环境：MAC OS

一、测试数据

测试数据库：test；测试表：tt

CREATE TABLE `tt` (
  `id` int(11) DEFAULT NULL,
  `name` varchar(100) DEFAULT NULL,
  KEY `name_idx` (`name`),
  KEY `id_idx` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8

插入测试数据：

insert into tt value(1, "a”);
insert into tt value(1, "b”);
insert into tt value(2, “b");

二、数据库服务设置

1、事务隔离级别设置

mysql> set global transaction_isolation = 'repeatable-read';
Query OK, 0 rows affected (0.00 sec)
mysql> select @@transaction_isolation;
+-------------------------+
| @@transaction_isolation |
+-------------------------+
| READ-UNCOMMITTED        |
+-------------------------+

2、锁等待时间设置

mysql> set global innodb_lock_wait_timeout=5;
Query OK, 0 rows affected (0.00 sec)
 
mysql> select @@innodb_lock_wait_timeout;
+----------------------------+
| @@innodb_lock_wait_timeout |
+----------------------------+
|                          5 |
+----------------------------+

3、附注

更改设置后，后续开启的连接 Session 才会生效。 

三、读未提交(READ-UNCOMMITTED)

开启两个连接 Session： 

Session 1Session 2

开启事务，更新 id 为 2 的记录 name 为 “ss" ，保持事务未提交：

Query OK, 0 rows affected (0.00 sec)
mysql> select * from tt;
+------+------+
| id   | name |
+------+------+
|    1 | a    |
|    1 | b    |
|    2 | b    |
+------+------+
3 rows in set (0.00 sec)
mysql> update tt set name = 'ss' where id = 2;
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0
 
 

开启事务，查询 id 为 2 的记录 name 值：

mysql> begin;
Query OK, 0 rows affected (0.00 sec)
mysql> select * from tt where id = 2;
+------+------+
| id   | name |
+------+------+
|    2 | ss   |
+------+———+ 

事务 2 可以查询到事务 1 未提交的数据变更。对于事务 2 来说，这条数据是脏数据。

四、读已提交(READ-COMMITTED)

解决 READ-UNCOMMITTED 隔离级别下产生的脏读现象。

设置事务隔离级别：

mysql> set global transaction_isolation = 'read-committed';
Query OK, 0 rows affected (0.00 sec)

重新开启测试 Session，查询事务隔离级别：

mysql> select @@transaction_isolation;
+-------------------------+
| @@transaction_isolation |
+-------------------------+
| READ-COMMITTED          |
+-------------------------+
Session 1Session 2
开启事务，更新 id 为 2 的记录 name 为 “ssr”： 
mysql> begin;
Query OK, 0 rows affected (0.00 sec)
 
mysql> update tt set name = 'ssr' where id = 2;
Query OK, 1 row affected (0.01 sec)
Rows matched: 1  Changed: 1  Warnings: 0
 
mysql> select * from tt where id = 2;
+------+------+
| id   | name |
+------+------+
|    2 | ssr  |
+------+------+
1 row in set (0.01 sec)
 
 
查询数据，无法查询到 事务 1 未提交的数据： 
mysql> begin;
Query OK, 0 rows affected (0.00 sec)
 
mysql> select * from tt where id = 2;
+------+------+
| id   | name |
+------+------+
|    2 | b    |
+------+------+
1 row in set (0.00 sec) 
提交事务： 
mysql> commit ;
Query OK, 0 rows affected (0.01 sec)
 
 
查询数据，得到的是事务 1 中已提交的数据变更： 
mysql> select * from tt where id = 2;
+------+------+
| id   | name |
+------+------+
|    2 | ssr    |
+------+------+
1 row in set (0.00 sec)
对于事务 2 来说，在事务 1 提交前后，获取到的数据是不一样的，即不可重复读问题。

五、可重复读(REPEATABLE-READ)

解决 READ-COMMITTED 隔离级别下产生的不可重复读现象。

Session 1中 设置事务隔离级别： 

mysql> set global transaction_isolation = 'repeatable-read';
Query OK, 0 rows affected (0.01 sec)

重新开启事务，查询隔离级别：

mysql> select @@transaction_isolation;
+-------------------------+
| @@transaction_isolation |
+-------------------------+
| REPEATABLE-READ         |
+-------------------------+
1 row in set (0.00 sec)
Session 1Session 2

Session 2 开启事务，查询数据：

mysql> begin;
Query OK, 0 rows affected (0.00 sec)
Database changed
mysql> select * from tt where id = 2;
+------+------+
| id   | name |
+------+------+
|    2 | b    |
+------+------+
1 row in set (0.00 sec)

更新 id 为 2 的记录 name 为 “ssrr”， 并提交事务：

mysql> begin;
Query OK, 0 rows affected (0.00 sec)
mysql> update tt set name = 'ssrr' where id = 2;
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0
mysql> commit;
Query OK, 0 rows affected (0.01 sec)
mysql> select * from tt where id = 2;
+------+------+
| id   | name |
+------+------+
|    2 | ssrr |
+------+------+
1 row in set (0.00 sec)  

Session 2 重新查询数据：

mysql> select * from tt where id = 2;
+------+------+
| id   | name |
+------+------+
|    2 | b    |
+------+------+

当前数据未变。

但是问题是，事务 1 已经进行了数据变更，并且提交，事务 2 无法获取所查记录最新变更信息。

为什么事务 2 前后两次相同查询所得的数据是一样的？

一致性读(consistent read)查询模式：基于【某一时刻】的【数据快照】提供读查询结果。无论查询的数据是否被其它事务所改变。这个【某一时刻】在 repeatable-read 隔离级别下为事务中第一次执行查询操作的时间点，read-committed 隔离级别下，数据快照会在每一次执行一致性读操作时进行重置。

幻读

如何避免：加X锁

Next-key lock：Record lock + Gap lock

六、关于 Next-key lock 加锁

调整表 tt 索引及数据：

mysql> show create table tt;
+-------+-------------------------------------------------------+
| Table | Create Table                                                                                                                                                                                      |
+-------+-------------------------------------------------------+
| tt    | CREATE TABLE `tt` (
  `id` int(11) NOT NULL,
  `name` varchar(100) DEFAULT NULL,
  `age` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `idx_age` (`age`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 |
+-------+-------------------------------------------------------+
1 row in set (0.00 sec)
mysql> select * from tt;
+-----+------+------+
| id  | name | age  |
+-----+------+------+
|  90 | aa   |   10 |
| 102 | bb   |   15 |
| 108 | cc   |   20 |
| 130 | dd   |   25 |
| 150 | ee   |   30 |
+-----+------+------+

1、等值条件

对于使用唯一性索引：加的锁为 Record lock

Session 1Session 2

开启事务，查询 id 为 108 记录加 X lock：

mysql> begin;
Query OK, 0 rows affected (0.00 sec)
 
mysql> select * from tt where id = 108 for update;
+-----+------+------+
| id  | name | age  |
+-----+------+------+
| 108 | cc   |   20 |
+-----+------+------+
1 row in set (0.01 sec)
 
 

开启事务，记录前后紧邻 gap 插入记录：

mysql> begin;
Query OK, 0 rows affected (0.00 sec)
 
mysql> insert into tt value(106, 'bc', 16);
Query OK, 1 row affected (0.00 sec)
 
mysql> insert into tt value(110, 'cd', 22);
Query OK, 1 row affected (0.00 sec)

记录均可成功插入

对于使用非唯一性索引：加的锁为 Record lock + Gap lock 前后紧邻 gap

：首先加锁 (15, 20]，因为是非唯一索引，继续向后查找到第一个不满足条件的元素 25 加 gap lock (20, 25)

Session 1 Session 2

开启事务，查询 age 为 20 记录加 X lock： 

mysql> begin;
Query OK, 0 rows affected (0.00 sec)
 
mysql> select * from tt where age = 20 for update;
+-----+------+------+
| id  | name | age  |
+-----+------+------+
| 108 | cc   |   20 |
+-----+------+------+
1 row in set (0.00 sec)
 
 

开启事务，记录紧邻前后 gap 插入记录：

mysql> begin;
Query OK, 0 rows affected (0.00 sec)
mysql> insert into tt value(106, 'bc', 18);
 
ERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transaction
 
mysql> insert into tt value(110, 'cd', 22);
 
ERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transaction

操作均被 block。

紧邻 gap 以外插入记录：

mysql> insert into tt value(100, 'ab', 12);
Query OK, 1 row affected (0.00 sec)
 
mysql> insert into tt value(140, 'de', 27);
Query OK, 1 row affected (0.00 sec)

记录均可成功插入

对于不使用索引的：加锁为全部记录及gap 

Session1
Session2

开启事务，查询 name 为 ‘cc’ 记录加 X lock：

mysql> begin;
Query OK, 0 rows affected (0.00 sec)
 
mysql> select * from tt where name = 'cc' for update;
+-----+------+------+
| id  | name | age  |
+-----+------+------+
| 108 | cc   |   20 |
+-----+------+------+
 
 

开启事务，各个间隙尝试插入记录：

mysql> begin;
Query OK, 0 rows affected (0.00 sec)
 
mysql> insert into tt value(80, 'pa', 5);
ERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transaction
mysql> insert into tt value(95, 'ab', 13);
ERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transaction
mysql> insert into tt value(105, 'bc', 18);
ERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transaction
mysql> insert into tt value(120, 'cd', 23);
ERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transaction
mysql> insert into tt value(140, 'de', 28);
ERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transaction
mysql> insert into tt value(160, 'en', 35);
ERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transaction

操作均被 block。

更新记录：

mysql> update tt set age = 21 where name = 'cc';
ERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transaction
mysql> update tt set age = 16 where name = 'bb';
ERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transaction

操作均被 block。

2、范围条件

使用唯一索引：

Session 1Session 2

开启事务，查询 id 为 108 的记录用以更新

mysql> select * from tt where id >= 108 and id < 109 for update;
+-----+------+------+
| id  | name | age  |
+-----+------+------+
| 108 | cc   |   20 |
+-----+------+------+
1 row in set (0.01 sec)
 
 

开启事务，间隙插入记录：

mysql> begin;
Query OK, 0 rows affected (0.00 sec)
 
mysql> insert into tt value(120, 'cd', 23);
ERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transaction
 
mysql> update tt set age = 26 where id = 130;
ERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transaction

操作被 block。

加锁说明：

>= 108 条件：主键索引加锁为 Record lock 记录 108

< 109 条件：因为不存在 109 记录，所以继续向右遍历至 130 不满足，加锁 (108, 130]

重新开启事务，右侧条件改为开区间 130：

mysql> rollback;
Query OK, 0 rows affected (0.00 sec)
 
mysql> begin;
Query OK, 0 rows affected (0.00 sec)
 
mysql> select * from tt where id >= 108 and id < 130 for update;
+-----+------+------+
| id  | name | age  |
+-----+------+------+
| 108 | cc   |   20 |
+-----+------+------+
1 row in set (0.01 sec)
 
 

开启事务，操作 130 后间隙插入记录及更新 id 为 130 记录：

mysql> insert into tt value(135, 'ce', 32);
Query OK, 1 row affected (0.01 sec)
 
mysql> rollback;
Query OK, 0 rows affected (0.01 sec)
 
mysql> begin;
Query OK, 0 rows affected (0.00 sec)
 
mysql> update tt set age = 26 where id = 130;
ERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transaction

插入操作成功，更新操作被 block。

加锁说明：

< 130 条件：存在 130 记录，加锁 (108, 130]

重新开启事务，右侧条件改为闭区间 130

mysql> rollback;
Query OK, 0 rows affected (0.00 sec)
 
mysql> begin;
Query OK, 0 rows affected (0.00 sec)
 
mysql> select * from tt where id >= 108 and id <= 130 for update;
 
+-----+------+------+
| id  | name | age  |
+-----+------+------+
| 108 | cc   |   20 |
| 130 | dd   |   25 |
+-----+------+------+
 
 

开启事务，操作 130 后间隙插入记录及更新 id 为 150 记录：

mysql> rollback;
Query OK, 0 rows affected (0.01 sec)
 
mysql> begin;
Query OK, 0 rows affected (0.00 sec)
 
mysql> insert into tt value(140, 'de', 28);
ERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transaction
mysql> update tt set age = 35 where id = 150;
ERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transaction

插入操作成功，更新操作被 block。

加锁说明：

<= 130 条件：存在 130 记录，加锁 (108, 130]，继续向右查询到不满足条件记录 150，加锁 (130, 150] 

 2、使用非唯一索引

Session 1Session 2

开启事务，查询 age 范围记录用以更新：

mysql> begin;
Query OK, 0 rows affected (0.00 sec)
 
mysql> select * from tt where age >= 20 and age < 21 for update;
+-----+------+------+
| id  | name | age  |
+-----+------+------+
| 108 | cc   |   20 |
+-----+------+------+
 
 

开启事务，间隙插入记录：

mysql> begin;
Query OK, 0 rows affected (0.00 sec)
 
mysql> insert into tt value(105, 'bc', 18);
ERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transaction
mysql> insert into tt value(120, 'cd', 23);
ERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transaction
mysql> insert into tt value(140, 'de', 28);
Query OK, 1 row affected (0.00 sec)
 
mysql> update tt set name = 'test' where age = 25;
ERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transaction

加锁说明：

>= 20 条件：非唯一索引，加锁为 (15, 20]

< 21 条件：因为不存在 21 记录，所以继续向右遍历至 25 不满足，加锁 (20, 25]

重新开启事务，右侧条件改为开区间 25

mysql> rollback;
Query OK, 0 rows affected (0.00 sec)
 
mysql> begin;
Query OK, 0 rows affected (0.00 sec)
 
mysql> select * from tt where age >= 20 and age < 25 for update;
+-----+------+------+
| id  | name | age  |
+-----+------+------+
| 108 | cc   |   20 |
+-----+------+------+
 
 

开启事务，操作 25 后间隙插入记录及更新 id 为 25 记录：

mysql> begin;
Query OK, 0 rows affected (0.00 sec)
 
mysql> insert into tt value(140, 'de', 28);
Query OK, 1 row affected (0.00 sec)
 
mysql> update tt set name = 'test' where age = 25;
ERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transaction

插入操作成功，更新操作被 block。

加锁说明：

< 25 条件：存在 25 记录，加锁 (20, 25]

重新开启事务，右侧条件改为闭区间 25

mysql> rollback;
Query OK, 0 rows affected (0.00 sec)
 
mysql> begin;
Query OK, 0 rows affected (0.00 sec)
 
mysql> select * from tt where age >= 20 and age <= 25 for update;
+-----+------+------+
| id  | name | age  |
+-----+------+------+
| 108 | cc   |   20 |
| 130 | dd   |   25 |
+-----+------+------+
 
 

开启事务，操作 25 后间隙插入记录及更新 age 为 30 记录：

mysql> rollback;
Query OK, 0 rows affected (0.00 sec)
 
mysql> begin;
Query OK, 0 rows affected (0.00 sec)
 
mysql> insert into tt value(140, 'de', 28);
ERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transaction
mysql> update tt set name = 'test' where age = 30;
ERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transaction

插入操作成功，更新操作被 block。

加锁说明：

<= 25 条件：存在 25 记录，加锁 (20, 25]，继续向右查询到不满足条件记录 30，加锁 (25, 30] 

3、 不使用索引

Session 1Session 2

开启事务，查询 name 范围记录用以更新：

mysql> select * from tt where name >= 'cc' and name < 'dd' for update;
+-----+------+------+
| id  | name | age  |
+-----+------+------+
| 108 | cc   |   20 |
+-----+------+------+
 
 

开启事务，间隙插入记录：

mysql> begin;
Query OK, 0 rows affected (0.00 sec)
 
mysql> insert into tt value(85, 'pa', 5);
ERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transaction
mysql> insert into tt value(95, 'ab', 13);
ERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transaction
mysql> insert into tt value(105, 'bc', 18);
ERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transaction
mysql> insert into tt value(120, 'cd', 23);
ERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transaction
mysql> insert into tt value(140, 'de', 28);
ERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transaction
mysql> insert into tt value(160, 'et', 50);
ERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transaction

加锁说明：

间隙全部加锁

七、附加订阅

windwant
关注
专栏目录
【MySQL】深入理解MySQL事务隔离级别与锁机制
金鳞踏雨
10-31 978
尽可能让所有数据检索都通过索引来完成，避免无索引行锁升级为表锁 合理设计索引，尽量缩小锁的范围 尽可能减少检索条件范围，避免间隙锁 尽量控制事务大小，减少锁定资源量和时间长度，涉及事务加锁的SQL尽量放在事务最后执行 尽可能低级别事务隔离
MySQL5-事务隔离级别和锁机制
程序员句号的博客
06-01 1440
我们的数据库一般都会并发执行多个事务，多个事务可能会并发的对相同的一批数据进行增删改查操作，可能就会导致我们说的脏写、脏读、不可重复读、幻读这些问题。这些问题的本质都是数据库的多事务并发问题，为了解决多事务并发问题，数据库设设计了事务隔离机制、锁机制、MVCC多版本并发控制隔离机制，用一整套机制来解决多事务并发问题。
MySQL 事务隔离级别与锁机制详解
kerwin的博客
10-05 7035
MySQL 事务隔离级别与锁机制详解
MySQL事务隔离级别详解
SO_zxn的博客
04-02 1011
mysql mysql事务隔离级别 脏读 不可重复读 幻读 mysql可重复读下如何解决幻读
深入理解Mysql事务隔离级别与锁机制
qq_43663493的博客
02-28 1460
MyISAM在执行查询语句SELECT前，会自动给涉及的所有表加读锁,在执行update、insert、delete操作会自动给涉及的表加写锁。InnoDB在执行查询语句SELECT时(非串行隔离级别)，不会加锁。但是update、insert、delete操作会加行锁。简而言之，就是。
MySQL事务隔离级别与锁机制
weixin_36279234的博客
01-12 471
事务四大特性（ACID） 原子性、一致性、隔离性、持久性 并发事务带来的问题 脏写：多个事务同时对某条数据进行修改更新操作，最后一个更新的事物会覆盖其他事物更新的结果 脏读：某一事物读取到了另一事物已经更新但未提交的数据 不可重复读：某一事物在多次读取某一数据时，出现数据不一样的情况，同一时刻查询相同语句出现不一样的结果，不符合隔离性 幻读：某一事物读取到其他事物提交的新增数据，不符合隔离性。 事物的隔离级别 读未提交：任何问题都有可能发生 读已提交：可解决脏读的问题 可重复读：解决脏读
深入理解mysql事务隔离级别和锁机制
chenjie的博客
03-15 2287
一、概述 我们日常在使用mysql的时候，可能同时会有多个事务对同一条或者同一批数据进行增删改查，然后会导致我们常说的脏写、脏读、不可重复读、幻读等现象。其实本质上，出现出现这些问题的本质就是数据库的多事务并发问题，针对这些问题，数据库设计了事务隔离机制、锁机制、MVCC多版本并发控制机制等来解决并发问题。接下来，我会详细的介绍这些机制，让大家深入理解数据库内部执行原理。 二、事务和ACID 事务是有一组sql语句组成的一个逻辑单元，具有如下四个属性： 1、原子性：事务是一个原子单元操作，多条sql多数据
mysql的事务及事务的隔离级别
weixin_43810802的博客
06-28 615
transactionmysql transactionmultiple transactions mysql transaction 事务就是一组sql语句同时执行，要么都成功，要么都失败。 因为mysql的update，delete等本身就是事务，而且默认是自动提交的，所以为了演示一组sql的行为，我们要关掉自动提交。 准备的表： 关闭自动提交： 我们要演示的逻辑是： Jack向Rose转账500块。 所以这里有两条sql： update money set balance=500 where u
MySQL高级篇——事务的隔离级别与简单应用
★★光亭★★
04-22 6610
MySQL高级篇——事务的隔离级别与简单应用
Mysql中事务特性、隔离级别以及案例演示
薯条和番茄酱的博客
11-04 320
1.事务用于保证数据的一致性，它由一组相关的dml语句组成，该组语句要么全部成功，要么全部失败。如：转账就要用事务来处理，保证数据的一致性。例子：2.事务与锁：当执行事务操作时（dml语句），mysql会在表面加锁，防止其他用户修改表的数据。
MYSQL事务隔离与锁
06-22
本套课程主要是对mysql的事务隔离级别以及锁相关知识进行深入讲解其中包括：mysql四大特性的深入理解、四种隔离级别的实现原理、一致性读的实现原理、全局锁、表锁、行锁，间隙锁的介绍与分析，对于难点和重点会使用...
mysql的事务，隔离级别和锁用法实例分析
09-08
设置MySQL事务隔离级别的命令如下： ```sql SET GLOBAL tx_isolation = '隔离级别'; SET SESSION tx_isolation = '隔离级别'; SET @@tx_isolation = '隔离级别'; ``` 在MySQL 8.0版本中，应使用`transaction_...
基于SpringBoot+Vue+MySQL的养老院管理系统
程序员大金的博客
09-20 843
基于SpringBoot+Vue+MySQL的养老院管理系统，附源码。
Mysql梳理7——分页查询
haozihua的博客
09-22 454
注意：MySQL 8.0中可以使用“LIMIT 3 OFFSET 4”，意思是获取从第5条记录开始后面的3条记录，和“LIMIT 4,3;如果我们知道返回结果只有 1 条，就可以使用 LIMIT 1 ，告诉 SELECT 语句只需要返回一条记录即可。背景1：查询返回的记录太多了，查看起来很不方便，怎么样能够实现分页查询呢？背景2：表里有 4 条数据，我们只想要显示第 2、3 条数据怎么办呢？所谓分页显示，就是将数据库中的结果集，一段一段显示出来需要的条件。第二个参数“行数”指示返回的记录条数。
MYSQL SWAP 内存 vm.swappiness
jnrjian的博客
09-20 965
关于 vm.swappiness 的困惑来自于这样一个事实：在较旧的 Red Hat 内核中，vm.swappiness 的值为 0 会导致最少量的交换以避免内存不足的情况。在较新的内核中（从 RHEL 内核 2.6.32-303 开始​​），值为 0 将完全禁用交换，但值为 1 将提供最少量的交换以避免内存不足的情况。在较旧的内核中，0 和 1 之间的实际差异并不大，但 1 是避免较新内核中出现 OOM 情况的安全设置（当然，假设有一些交换空间可用）。考虑到系统自动将未使用的页面交换到磁盘。
Linux递归找出目录下最近被修改文件（最近一段时间内被修改过的最新文件）（最近修改文件、最新文件、查找文件）（监控目录、监控mysql文件）
最新发布
Dontla的博客
09-26 496
目录下最近60分钟内修改的最新文件。如果你需要查找的时间范围不同，可以调整。表示最近10分钟）。
Web+Mysql——MyBatis
qq_73643693的博客
09-20 1484
MyBatis 是一款优秀的持久层框架，用于简化 JDBC 开发MyBatis 本是 Apache 的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis。2013年11月迁移到Github官网：https://mybatis.org/mybatis-3/zh/index.html负责将数据到保存到数据库的那一层代码。以后开发我们会将操作数据库的Java代码作为持久层。
MySQL --基本查询(上）
2301_79274600的博客
09-23 1154
语法： 示例： 创建一张学生表 1.1单行数据+全列插入 插入两条记录，value_list 数量必须和指定列数量及顺序一致 由于 主键 或者 唯一键 对应的值已经存在而导致插入失败 可以选择性的进行同步更新操作 语法： 冲突数据被更新– ON DUPLICATE KEY 当发生重复key的时候– 主键 或者 唯一键 没有冲突，则直接插入； – 主键 或者 唯一键 如果冲突，则删除后再插入 语法： 示例： 创建表结构 插入测试数据 – 通常情况下不建议使用 * 进行全列查询 – 1. 查询的列越多，意
二、MySQL环境搭建
weixin_44063529的博客
09-23 1736
这篇文章是关于MySQL数据库的安装、配置和使用的详细指南。它包括了MySQL的卸载步骤、不同版本的下载和安装过程、登录方法、基本的数据库操作演示以及图形化管理工具的使用。此外，文章还提供了解决安装失败问题的方法和MySQL编码设置的说明。对于MySQL8.0，特别强调了默认字符集的变化和新密码验证插件的问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

windwant

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值