PHP数据库锁机制：行锁、表锁与乐观锁/悲观锁的应用
大家好，今天我们来聊聊PHP开发中数据库锁机制的应用。在高并发环境下，对数据库的并发访问控制至关重要，可以防止数据不一致、丢失更新等问题。锁机制是实现并发控制的重要手段。我们将深入探讨行锁、表锁以及乐观锁和悲观锁的概念，并结合实际业务场景，分析它们在PHP中的应用。
一、锁的基本概念
在多用户并发访问数据库时，可能会出现以下问题：
- 丢失更新: 多个用户同时读取同一条数据，然后分别修改并提交，导致一个用户的修改被另一个用户的修改覆盖。
- 脏读: 一个用户读取了另一个用户尚未提交的修改，如果另一个用户最终回滚了修改，那么第一个用户读取的数据就是错误的。
- 不可重复读: 同一个用户在同一个事务中多次读取同一条数据，由于其他用户的修改，导致每次读取的结果不一致。
- 幻读: 同一个用户在同一个事务中多次执行相同的查询，由于其他用户的插入或删除操作，导致每次查询的结果集数量不一致。
锁机制的目的就是为了解决上述问题，它通过限制并发访问，确保数据的一致性和完整性。
二、行锁和表锁
行锁和表锁是数据库提供的两种基本的锁粒度。
- 表锁: 锁定整个表，任何用户在获得表锁后，才能对表进行读写操作。 表锁的优点是实现简单，开销较小，但并发性能较差，适用于并发较低的场景，或者需要批量操作整个表的场景。
- 行锁: 锁定表中的某一行或多行数据，允许其他用户访问表中的其他行。行锁的优点是并发性能较高，但实现复杂，开销较大，适用于并发较高的场景，或者只需要操作部分数据的场景。
2.1 表锁
在MySQL中，可以使用LOCK TABLES语句来显式地锁定表。
<?php
$pdo = new PDO("mysql:host=localhost;dbname=testdb", "username", "password");
try {
$pdo->beginTransaction();
// 锁定表
$stmt = $pdo->prepare("LOCK TABLES users WRITE"); // WRITE 锁定用于写操作
$stmt->execute();
// 执行操作（例如更新）
$stmt = $pdo->prepare("UPDATE users SET balance = balance + 10 WHERE id = 1");
$stmt->execute();
// 提交事务
$pdo->commit();
// 解锁表
$stmt = $pdo->prepare("UNLOCK TABLES");
$stmt->execute();
} catch (PDOException $e) {
$pdo->rollBack();
echo "Error: " . $e->getMessage();
}
?>注意:
- 必须在事务中进行锁定操作，才能保证数据的一致性。
- 使用完表锁后，必须使用
UNLOCK TABLES语句释放锁，否则其他用户将无法访问该表。 LOCK TABLES可以一次锁定多个表。例如LOCK TABLES users WRITE, products READ;
表锁的适用场景:
- 备份数据库。
- 批量导入数据。
- 需要对整个表进行维护操作时。
2.2 行锁
行锁由存储引擎实现，不同的存储引擎支持的锁机制有所不同。MySQL的InnoDB引擎支持行锁。InnoDB通过索引来实现行锁，这意味着只有通过索引条件检索的数据才会使用行锁，否则会使用表锁。
隐式行锁:
InnoDB会在执行UPDATE、DELETE等语句时，自动对涉及的行加上排他锁（Exclusive Lock，也称为写锁），防止其他事务同时修改这些行。
<?php
$pdo = new PDO("mysql:host=localhost;dbname=testdb", "username", "password");
try {
$pdo->beginTransaction();
// 更新操作会自动加上行锁
$stmt = $pdo->prepare("UPDATE users SET balance = balance + 10 WHERE id = 1");
$stmt->execute();
// 提交事务
$pdo->commit();
} catch (PDOException $e) {
$pdo->rollBack();
echo "Error: " . $e->getMessage();
}
?>在这个例子中，当执行UPDATE语句时，InnoDB会自动对users表中id = 1的行加上行锁，防止其他事务同时修改该行。当事务提交或回滚后，行锁会自动释放。
显式行锁:
可以使用SELECT ... FOR UPDATE语句来显式地对行加上排他锁。
<?php
$pdo = new PDO("mysql:host=localhost;dbname=testdb", "username", "password");
try {
$pdo->beginTransaction();
// 显式锁定一行
$stmt = $pdo->prepare("SELECT balance FROM users WHERE id = 1 FOR UPDATE");
$stmt->execute();
$user = $stmt->fetch(PDO::FETCH_ASSOC);
// 执行操作
$newBalance = $user['balance'] + 10;
$stmt = $pdo->prepare("UPDATE users SET balance = ? WHERE id = 1");
$stmt->execute([$newBalance]);
// 提交事务
$pdo->commit();
} catch (PDOException $e) {
$pdo->rollBack();
echo "Error: " . $e->getMessage();
}
?>在这个例子中，SELECT ... FOR UPDATE语句会对users表中id = 1的行加上排他锁，直到事务提交或回滚后才释放。 其他事务尝试修改这行数据将会被阻塞，直到锁释放。
可以使用SELECT ... LOCK IN SHARE MODE 语句来显式地对行加上共享锁(Shared Lock, 也称为读锁)。多个事务可以同时持有共享锁，但是只有一个事务可以持有排他锁。
行锁的适用场景:
- 高并发的更新操作，例如秒杀、抢购等。
- 需要保证数据一致性的场景，例如银行转账。
行锁的注意事项:
- 尽可能使用索引作为
WHERE条件，避免锁住整个表。 - 尽量缩小事务范围，减少锁的持有时间。
- 注意死锁问题，可以使用
SHOW ENGINE INNODB STATUS命令查看死锁信息。
2.3 行锁和表锁的对比
| 特性 | 行锁 | 表锁 |
|---|---|---|
| 锁粒度 | 行级 | 表级 |
| 并发性能 | 高 | 低 |
| 开销 | 大 | 小 |
| 适用场景 | 高并发，对部分数据进行操作 | 并发较低，或需要对整个表进行批量操作 |
| 实现难度 | 复杂 | 简单 |
| 死锁风险 | 高 | 低 |
三、乐观锁和悲观锁
乐观锁和悲观锁是两种不同的并发控制思想。
- 悲观锁: 假设最坏的情况，每次读取数据都认为有其他事务会修改，因此在读取数据时就加上锁，防止其他事务修改。上面介绍的行锁和表锁都是悲观锁。
- 乐观锁: 假设最好的情况，每次读取数据都认为没有其他事务会修改，因此在读取数据时不加锁。但是在更新数据时，会检查数据是否被其他事务修改过，如果被修改过，则更新失败。
3.1 悲观锁
悲观锁的实现方式主要依赖数据库提供的锁机制，例如行锁和表锁。我们前面已经介绍了行锁和表锁的使用，这里不再赘述。
悲观锁的优点:
- 能够保证数据的一致性和完整性。
- 适用于并发冲突较多的场景。
悲观锁的缺点:
- 并发性能较低，因为需要加锁和释放锁。
- 可能导致死锁。
3.2 乐观锁
乐观锁通常通过版本号或者时间戳来实现。
3.2.1 版本号机制
在表中增加一个版本号字段version，每次更新数据时，都将版本号加1。在更新数据时，需要比较当前版本号和读取时的版本号是否一致，如果一致，则更新成功；否则，更新失败。
数据库表结构：
CREATE TABLE products (
id INT PRIMARY KEY AUTO_INCREMENT,
name VARCHAR(255) NOT NULL,
stock INT NOT NULL,
version INT NOT NULL DEFAULT 0
);PHP代码示例：
<?php
$pdo = new PDO("mysql:host=localhost;dbname=testdb", "username", "password");
function purchaseProduct($productId, $quantity) {
global $pdo;
try {
$pdo->beginTransaction();
// 1. 读取商品信息和版本号
$stmt = $pdo->prepare("SELECT stock, version FROM products WHERE id = ?");
$stmt->execute([$productId]);
$product = $stmt->fetch(PDO::FETCH_ASSOC);
if (!$product) {
throw new Exception("Product not found");
}
$stock = $product['stock'];
$version = $product['version'];
// 2. 检查库存是否足够
if ($stock < $quantity) {
throw new Exception("Insufficient stock");
}
// 3. 更新库存和版本号
$newStock = $stock - $quantity;
$newVersion = $version + 1;
$stmt = $pdo->prepare("UPDATE products SET stock = ?, version = ? WHERE id = ? AND version = ?");
$stmt->execute([$newStock, $newVersion, $productId, $version]);
// 4. 检查更新是否成功
if ($stmt->rowCount() == 0) {
throw new Exception("Update failed due to concurrent modification");
}
// 5. 提交事务
$pdo->commit();
return true;
} catch (PDOException $e) {
$pdo->rollBack();
throw $e;
} catch (Exception $e) {
$pdo->rollBack();
throw $e;
}
}
// 使用示例
try {
if (purchaseProduct(1, 1)) {
echo "Purchase successfuln";
}
} catch (Exception $e) {
echo "Purchase failed: " . $e->getMessage() . "n";
}
?>在这个例子中，UPDATE语句中增加了version = ?的条件，只有当当前版本号和读取时的版本号一致时，才能更新成功。如果更新失败，说明数据被其他事务修改过，需要重新读取数据并重试。
3.2.2 时间戳机制
与版本号类似，可以使用时间戳来判断数据是否被修改过。在表中增加一个时间戳字段update_time，每次更新数据时，都将时间戳更新为当前时间。在更新数据时，需要比较当前时间戳和读取时的时间戳是否一致，如果一致，则更新成功；否则，更新失败。 这种方式不如版本号精确，但在某些场景下也足够使用。
乐观锁的优点:
- 并发性能较高，因为不需要加锁和释放锁。
- 避免了死锁。
乐观锁的缺点:
- 可能出现更新失败，需要重试。
- 适用于并发冲突较少的场景。
3.3 乐观锁和悲观锁的对比
| 特性 | 乐观锁 | 悲观锁 |
|---|---|---|
| 加锁方式 | 无锁，通过版本号或时间戳判断是否被修改 | 加锁，使用数据库提供的锁机制 |
| 并发性能 | 高 | 低 |
| 冲突处理 | 更新失败，需要重试 | 阻塞等待，直到获得锁 |
| 适用场景 | 并发冲突较少，允许一定的更新失败 | 并发冲突较多，需要保证数据的一致性和完整性 |
| 实现难度 | 简单 | 复杂 |
| 死锁风险 | 无 | 有 |
四、业务场景应用举例
4.1 秒杀场景
秒杀场景是典型的并发冲突较高的场景，可以使用乐观锁或悲观锁来解决。
-
乐观锁: 使用版本号机制，每次更新库存时都比较版本号，如果版本号不一致，则更新失败，提示用户稍后重试。
// (参考上面的 版本号机制的代码) -
悲观锁: 使用行锁，在更新库存前先锁定商品行，防止其他事务同时修改库存。
<?php $pdo = new PDO("mysql:host=localhost;dbname=testdb", "username", "password"); function purchaseProduct($productId, $quantity) { global $pdo; try { $pdo->beginTransaction(); // 1. 锁定商品行 $stmt = $pdo->prepare("SELECT stock FROM products WHERE id = ? FOR UPDATE"); $stmt->execute([$productId]); $product = $stmt->fetch(PDO::FETCH_ASSOC); if (!$product) { throw new Exception("Product not found"); } $stock = $product['stock']; // 2. 检查库存是否足够 if ($stock < $quantity) { throw new Exception("Insufficient stock"); } // 3. 更新库存 $newStock = $stock - $quantity; $stmt = $pdo->prepare("UPDATE products SET stock = ? WHERE id = ?"); $stmt->execute([$newStock, $productId]); // 4. 提交事务 $pdo->commit(); return true; } catch (PDOException $e) { $pdo->rollBack(); throw $e; } catch (Exception $e) { $pdo->rollBack(); throw $e; } } // 使用示例 try { if (purchaseProduct(1, 1)) { echo "Purchase successfuln"; } } catch (Exception $e) { echo "Purchase failed: " . $e->getMessage() . "n"; } ?>
在秒杀场景中，通常使用乐观锁，因为乐观锁的并发性能更高，即使出现更新失败，也可以提示用户稍后重试，不会影响整体性能。
4.2 银行转账场景
银行转账场景需要保证数据的一致性和完整性，可以使用悲观锁来解决。
<?php
$pdo = new PDO("mysql:host=localhost;dbname=testdb", "username", "password");
function transfer($fromUserId, $toUserId, $amount) {
global $pdo;
try {
$pdo->beginTransaction();
// 1. 锁定转出账户
$stmt = $pdo->prepare("SELECT balance FROM users WHERE id = ? FOR UPDATE");
$stmt->execute([$fromUserId]);
$fromUser = $stmt->fetch(PDO::FETCH_ASSOC);
if (!$fromUser) {
throw new Exception("From user not found");
}
$fromBalance = $fromUser['balance'];
// 2. 锁定转入账户
$stmt = $pdo->prepare("SELECT balance FROM users WHERE id = ? FOR UPDATE");
$stmt->execute([$toUserId]);
$toUser = $stmt->fetch(PDO::FETCH_ASSOC);
if (!$toUser) {
throw new Exception("To user not found");
}
$toBalance = $toUser['balance'];
// 3. 检查转出账户余额是否足够
if ($fromBalance < $amount) {
throw new Exception("Insufficient balance");
}
// 4. 更新转出账户余额
$newFromBalance = $fromBalance - $amount;
$stmt = $pdo->prepare("UPDATE users SET balance = ? WHERE id = ?");
$stmt->execute([$newFromBalance, $fromUserId]);
// 5. 更新转入账户余额
$newToBalance = $toBalance + $amount;
$stmt = $pdo->prepare("UPDATE users SET balance = ? WHERE id = ?");
$stmt->execute([$newToBalance, $toUserId]);
// 6. 提交事务
$pdo->commit();
return true;
} catch (PDOException $e) {
$pdo->rollBack();
throw $e;
} catch (Exception $e) {
$pdo->rollBack();
throw $e;
}
}
// 使用示例
try {
if (transfer(1, 2, 10)) {
echo "Transfer successfuln";
}
} catch (Exception $e) {
echo "Transfer failed: " . $e->getMessage() . "n";
}
?>在这个例子中，使用行锁锁定了转出账户和转入账户，防止其他事务同时修改这两个账户的余额，保证了转账操作的原子性。
五、总结：选择合适的锁策略
在PHP开发中，选择合适的锁机制非常重要，需要根据具体的业务场景进行权衡。
- 如果并发冲突较少，可以选择乐观锁，提高并发性能。
- 如果并发冲突较多，需要保证数据的一致性和完整性，可以选择悲观锁。
- 在高并发场景下，尽量使用行锁，减少锁的粒度，提高并发性能。
- 在需要对整个表进行操作时，可以使用表锁。
希望今天的分享对大家有所帮助。 谢谢！