文章目录
- 前言
- MySQL锁的详解
- 1. 表级锁
- 1.1 读锁（共享锁）
- 对比
- 查询操作
- 更新操作
- 获取写锁
- 获取读锁
- 1.2 写锁（排他锁）
- 对比
- 获取写锁
- 对表进行事务操作
- 获取表的读锁
- 对表进行查询操作
- 2. 行级锁
- 2.1 共享锁
- 2.2 排他锁
- 锁的应用场景
- 1.1 并发读取
- 1.2 并发修改
- 总结
前言
当涉及到数据库并发访问和数据一致性时，MySQL 锁机制发挥着重要的作用。MySQL 提供了不同级别的锁，包括表级锁和行级锁，以及其他类型的锁，用于实现并发控制。本文将详细介绍 MySQL 锁的应用，包括锁的类型、使用场景和示例代码，以帮助读者更好地理解和使用 MySQL 锁。
MySQL锁的详解
1. 表级锁
表级锁适用于对整个表进行锁定，限制对整个表的访问。MySQL 提供了读锁和写锁，分别允许多个会话同时获取读锁，而只允许一个会话获取写锁。
package com.example.onlystudent.mysql.锁;
/**
* @BelongsProject: OnlyStudent
* @BelongsPackage: com.example.onlystudent.mysql.锁
* @Author: gepengjun
* @CreateTime: 2023-05-16 08:14
* @Description: 表级锁示例
* @Version: 1.0
*/
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
public class TableLevelLockExample {
public static void main(String[] args) {
//String url = "jdbc:mysql://localhost:3306/shop";
//String username = "root";
//String mima= "";
try (Connection connection = DriverManager.getConnection(url, username, password)) {
connection.setAutoCommit(false);
// 事务1获取表级写锁
Statement stmt1 = connection.createStatement();
stmt1.execute("LOCK TABLES shop_product WRITE");
// 事务2尝试获取表级读锁
Statement stmt2 = connection.createStatement();
stmt2.execute("LOCK TABLES shop_product READ");
// 处理数据
// ...
//提交事务
connection.commit();
//释放锁
stmt2.execute("UNLOCK TABLES");
} catch (SQLException e) {
e.printStackTrace();
}
}
}
1.1 读锁（共享锁）
读锁，也称为共享锁，允许多个会话同时获取读锁，不阻塞其他会话的读取操作。读锁适用于并发读取数据的场景。
示例代码：
-- 获取读锁
LOCK TABLES table_name READ;
-- 执行读取操作
SELECT * FROM table_name;
-- 解锁
UNLOCK TABLES;
对比
现在执行java程序，这里执行的是事务二，可以看到事务二是执行的读锁，在执行完读锁后去Navicat中去看看执行一些SQL语句看看效果。
查询操作
可以看到正常的select语句还是可以执行的。
更新操作
这里执行更新操作，可以看到提示“表“shop_product”已被READ锁锁定，无法更新”，这里就不展示删除和添加了，因为它俩和更新都是同类型的，都对表进行了事务级别的操作。所以得到的结果也是无法新增或者删除。因为表已经被锁定了。
获取写锁
执行完LOCK TABLES shop_product WRITE后Navicat一直处理等待中，也就是说当一个事务获取了一张表的读锁时，其它事务就不可以获取这张表的写锁。
获取读锁
可以看到啊，很快啊!
直接获取到这张表的读锁，这也是上面说的它是共享锁。
1.2 写锁（排他锁）
写锁，也称为排他锁，只允许一个会话获取写锁，其他会话无法同时获取读锁或写锁。写锁适用于修改数据的场景，保证数据的一致性。
示例代码：
-- 获取写锁
LOCK TABLES table_name WRITE;
-- 执行写入操作
UPDATE table_name SET column_name = value;
-- 解锁
UNLOCK TABLES;
对比
获取写锁
在执行Java程序中事务1通过使用表级别的写锁，获取到了shop_product这个表的锁，我在Navicat中同样执行写锁结果却是处于等待状态，在等待这个表的写锁（排它锁）释放。
对表进行事务操作
同理，那么当我去执行shop_product这个表的更新操作时肯定是不会成功的。此时我Java程序中写锁还没有释放，所以在Navicat中执行的对表的操作就不会被执行，只能等到Java程序中的事务提交才会释放锁。
获取表的读锁
在事务1获取到shop_product这个表的写锁后，其它事务想要获取这个表的读锁时也是不能获取的。
对表进行查询操作
这也体现写锁的排它性了，某一时刻只能有一个事务获取这张表的使用权。
2. 行级锁
行级锁适用于对特定行进行锁定，限制对行的访问和修改。MySQL 提供了共享锁和排他锁，用于实现更细粒度的并发控制。
package com.example.onlystudent.mysql.锁;
/**
* @BelongsProject: OnlyStudent
* @BelongsPackage: com.example.onlystudent.mysql.锁
* @Author: gepengjun
* @CreateTime: 2023-05-15 21:06
* @Description: 行级锁示例
* @Version: 1.0
*/
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class RowLevelLockExample {
public static void main(String[] args) {
String url = "jdbc:mysql://localhost:3306/shop";
String username = "root";
String mima= "password";
try (Connection connection = DriverManager.getConnection(url, username, password)) {
connection.setAutoCommit(false);
// 事务1获取行级排他锁
PreparedStatement stmt1 = connection.prepareStatement("SELECT * FROM shop_product WHERE pid = ? FOR UPDATE");
stmt1.setInt(1, 1);
ResultSet rs1 = stmt1.executeQuery();
rs1.next();
System.out.println(rs1.getString("pname"));
// 事务2尝试获取行级共享锁，需要等待事务1释放排他锁
PreparedStatement stmt2 = connection.prepareStatement("SELECT * FROM shop_product WHERE pid = ? LOCK IN SHARE MODE");
stmt2.setInt(1, 1);
ResultSet rs2 = stmt2.executeQuery();
rs2.next();
System.out.println(rs2.getString("pname"));
// 处理数据
// ...
connection.commit();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
2.1 共享锁
共享锁允许多个会话同时获取共享锁，其他会话可以读取同一行的数据，但无法获取排他锁。共享锁适用于多个会话并发读取同一行数据的场景。
示例代码：
-- 获取共享锁
SELECT * FROM table_name WHERE condition LOCK IN SHARE MODE;
在我们java程序中事务1执行共享锁的时候，在Navicat中使用排它锁获取pid=1的数据时就获取不到，也就是说在当一个事务对一行数据开启共享锁时，其他事务就不可以使用排它锁来获取这条数据
2.2 排他锁
排他锁只允许一个会话获取排他锁，其他会话无法同时获取共享锁或排他锁。排他锁适用于需要修改特定行数据的场景。
示例代码：
-- 获取排他锁
SELECT * FROM table_name WHERE condition FOR UPDATE;
这里进行验证，当事务一执行后通过，再去Navicat中执行修改pid为1的数据时，这个SQL语句就一直处于等待中，直到我们上述的代码中提交事物后在Navicat中执行的SQL语句才会被执行否则将会一直等待到超时。
并且在使用排它锁的时间内，其它线程并不能使用共享锁来获取这个数据，也就是说当一个事务使用排它锁锁定了一条数据，则其它的事务就不可以使用行级锁来去获取这条数据。
锁的应用场景
MySQL 锁机制在以下场景中发挥重要作用：
1.1 并发读取
在多个会话需要同时读取同一张表的数据时，在并发读取的场景中，可以使用共享锁来保证数据的一致性。多个会话可以同时获取共享锁，读取数据，并在读取完成后释放锁。
示例代码：
// 会话1
String query = "SELECT * FROM table_name WHERE condition LOCK IN SHARE MODE";
Statement statement1 = connection1.createStatement();
ResultSet resultSet1 = statement1.executeQuery(query);
while (resultSet1.next()) {
// 读取数据
}
statement1.close();
// 会话2
String query = "SELECT * FROM table_name WHERE condition LOCK IN SHARE MODE";
Statement statement2 = connection2.createStatement();
ResultSet resultSet2 = statement2.executeQuery(query);
while (resultSet2.next()) {
// 读取数据
}
statement2.close();
LOCK IN SHARE MODE 是 MySQL 中的一种锁定模式，用于在查询过程中获取共享锁。它适用于并发读取操作，允许多个事务同时读取相同的数据，而不会相互干扰或产生冲突。
当使用 SELECT 查询语句时，在需要获取共享锁的地方可以添加 LOCK IN SHARE MODE 子句。示例如下：
SELECT * FROM table_name WHERE column = 'value' LOCK IN SHARE MODE;
使用 LOCK IN SHARE MODE 的目的是为了防止在读取数据的同时，其他事务对该数据进行修改或删除操作，以确保数据的一致性。
LOCK IN SHARE MODE 的特点和行为如下：
- 共享锁（Shared Lock）：在查询过程中获取共享锁，允许其他事务也获取共享锁并同时读取相同的数据。
- 共享冲突：共享锁与共享锁之间不存在冲突，多个事务可以同时获取共享锁。
- 排斥写入：共享锁与排它锁（Exclusive Lock）之间存在冲突。如果一个事务获取了共享锁，则其他事务无法获取排它锁并执行写入操作。
- 阻止修改：获取共享锁的事务只能读取数据，不能修改数据。
通过使用 LOCK IN SHARE MODE，可以实现多个事务并发读取相同的数据，提高并发性能，并确保数据的一致性。然而，需要注意在并发读取的情况下，读取的数据可能不是最新的，因为其他事务可能在查询过程中对数据进行了修改。
1.2 并发修改
在多个会话需要同时修改同一张表的数据时，需要使用写锁来保证数据的一致性。只有一个会话能够获取写锁，其他会话需要等待锁的释放。
这里可以使用行级排它锁或者表级排它锁获取这个表的使用权，然后进行修改操作。
示例代码：
// 会话1
String updateQuery = "UPDATE table_name SET column_name = value WHERE condition";
Statement statement1 = connection1.createStatement();
statement1.executeUpdate(updateQuery);
statement1.close();
// 会话2
String updateQuery = "UPDATE table_name SET column_name = value WHERE condition";
Statement statement2 = connection2.createStatement();
statement2.executeUpdate(updateQuery);
statement2.close();
需要注意的是，在使用锁时要避免死锁的发生。死锁是指多个会话相互等待对方持有的锁而无法继续执行的情况。为了避免死锁，可以按照固定的顺序获取锁，或者使用超时机制来放弃锁等待。
总结
MySQL 锁机制在并发访问和数据一致性控制中起着重要的作用。通过合理使用表级锁和行级锁，可以实现对数据的并发访问和修改控制。在实际应用中，需要根据具体场景选择合适的锁，并合理管理锁的释放和避免死锁的发生。了解和掌握 MySQL 锁的使用方法，对于开发高性能、稳定的数据库应用非常重要。
