概述
本文介绍了乐观锁和悲观锁的基本概念，包括它们的假设、实现方式以及应用场景。文章详细解释了乐观锁和悲观锁之间的区别，并提供了相关的代码示例来说明如何在实际项目中使用乐观锁和悲观锁。通过这些内容，读者可以更好地理解乐观锁悲观锁入门的相关知识。
1. 乐观锁与悲观锁的基本概念什么是乐观锁
乐观锁是一种乐观的并发控制策略，它假设并发操作不会产生冲突，因此在执行操作前不会加锁。乐观锁通常通过版本号或时间戳等机制来判断数据是否被其他事务修改过。乐观锁的主要实现方式是通过检查数据的版本号或时间戳来确定数据是否被修改过。如果数据未被修改，则更新成功；如果数据已被修改，则更新失败，需要回滚操作。
什么是悲观锁
悲观锁是一种保守的并发控制策略，它假设并发操作会产生冲突，因此在执行操作前会加锁。悲观锁通过对数据加锁来避免并发冲突，确保在事务执行过程中，其他事务不能修改该数据。在事务提交后，锁才会被释放。悲观锁通常使用数据库的锁机制来实现，也可以通过代码级别的锁来实现。
两者之间的区别
乐观锁和悲观锁的主要区别在于它们的假设和实现方式：
- 假设不同：乐观锁假设并发操作不会产生冲突，而悲观锁假设并发操作会产生冲突。乐观锁基于这种假设，认为冲突概率低，因此在操作前不加锁；而悲观锁则认为冲突概率高，因此在操作前会加锁以避免冲突。
- 实现方式：乐观锁通过版本号或时间戳来判断数据是否被修改过；悲观锁通过数据库锁或代码级别的锁来避免并发冲突。
- 性能影响：乐观锁由于不加锁，因此在并发操作较少时性能较好；悲观锁由于加锁，可能会影响并发性能，但能更有效地避免数据冲突。
使用版本号实现乐观锁
版本号乐观锁通过给每个数据条目添加一个版本号字段来实现。当数据被修改时，版本号会递增。在更新数据时，会先检查版本号是否与预期的版本号一致，如果不一致则说明数据已被其他事务修改过。
以下是一个简单的Python示例：
class VersionedModel:
def __init__(self, version):
self.version = version
def update(self, new_data, expected_version):
if self.version != expected_version:
raise Exception("Data has been updated by another transaction.")
self.data = new_data
self.version += 1
print(f"Updated data to {new_data} with version {self.version}.")
model = VersionedModel(version=1)
model.update(new_data="New data", expected_version=1)
model.update(new_data="Another update", expected_version=2)使用时间戳实现乐观锁
时间戳乐观锁通过给每个数据条目添加一个时间戳字段来实现。当数据被修改时，时间戳会更新为当前时间。在更新数据时，会先检查时间戳是否与预期的时间戳一致，如果不一致则说明数据已被其他事务修改过。
以下是一个简单的Python示例：
from datetime import datetime
class TimestampedModel:
def __init__(self, timestamp):
self.timestamp = timestamp
self.data = "Initial data"
def update(self, new_data, expected_timestamp):
current_timestamp = datetime.now()
if self.timestamp != expected_timestamp:
raise Exception("Data has been updated by another transaction.")
self.data = new_data
self.timestamp = current_timestamp
print(f"Updated data to {new_data} with timestamp {self.timestamp}.")
model = TimestampedModel(timestamp=datetime.now())
model.update(new_data="New data", expected_timestamp=model.timestamp)
model.update(new_data="Another update", expected_timestamp=model.timestamp)使用数据库锁
数据库锁是悲观锁的一种常见实现方式，通过在事务开始时对数据加锁来避免并发冲突。常见的数据库锁包括行锁、表锁等。当其他事务尝试修改已加锁的数据时，会等待锁释放或抛出异常。
以下是一个简单的SQL示例，使用MySQL数据库：
-- 创建表
CREATE TABLE users (
id INT PRIMARY KEY,
name VARCHAR(255),
version INT
);
-- 插入数据
INSERT INTO users (id, name, version) VALUES (1, 'Alice', 1);
-- 开始事务
START TRANSACTION;
-- 获取行锁
SELECT * FROM users WHERE id = 1 FOR UPDATE;
-- 更新数据
UPDATE users SET name = 'Bob', version = 2 WHERE id = 1;
-- 提交事务
COMMIT;
-- 查询数据
SELECT * FROM users;使用代码级别的锁
代码级别的锁是通过编程语言提供的锁机制来实现悲观锁的一种方式。常见的锁机制有Python的threading.Lock、Java的synchronized关键字等。
以下是一个简单的Python示例：
import threading
class PessimisticModel:
def __init__(self):
self.data = "Initial data"
self.lock = threading.Lock()
def update(self, new_data):
with self.lock:
self.data = new_data
print(f"Updated data to {self.data}.")
model = PessimisticModel()
thread1 = threading.Thread(target=model.update, args=("Data 1",))
thread2 = threading.Thread(target=model.update, args=("Data 2",))
thread1.start()
thread2.start()
thread1.join()
thread2.join()何时使用乐观锁
乐观锁适用于以下场景：
- 并发操作较少，冲突概率低。
- 需要高性能，不能容忍锁带来的性能损失。
- 业务逻辑允许部分数据冲突，可以回滚操作。
乐观锁的优点和缺点
优点
- 高性能：不加锁，避免了锁的开销。
- 简单实现：通过版本号或时间戳判断数据是否被修改。
缺点
- 数据冲突：如果数据被其他事务修改，则更新会失败。
- 回滚操作：需要显式处理数据冲突，回滚操作。
何时使用悲观锁
悲观锁适用于以下场景：
- 并发操作频繁，冲突概率高。
- 需要保证数据的一致性和完整性。
- 业务逻辑不允许数据冲突。
悲观锁的优点和缺点
优点
- 数据一致性：通过加锁确保数据在事务执行期间不会被其他事务修改。
- 避免冲突：避免了数据冲突的可能性。
缺点
- 性能损失：加锁会影响并发性能。
- 死锁风险：多个事务之间可能会发生死锁。
通过案例理解如何在实际项目中应用乐观锁和悲观锁
乐观锁的实际应用案例
假设有一个在线购物系统，用户可以添加商品到购物车，然后进行结算。在结算时，需要确保商品的数量和价格等信息没有被其他操作修改过。
class ShoppingCart:
def __init__(self, items):
self.items = items
def checkout(self, item_id, quantity, expected_version):
item = self.items.get(item_id)
if item is None:
raise Exception("Item not found.")
if item.version != expected_version:
raise Exception("Item has been updated by another transaction.")
# 减少库存
item.quantity -= quantity
item.version += 1
print(f"Checked out {quantity} of {item.name} with version {item.version}.")
class Item:
def __init__(self, name, quantity, price, version):
self.name = name
self.quantity = quantity
self.price = price
self.version = version
items = {
1: Item("Apple", 100, 0.5, 1),
2: Item("Banana", 50, 0.3, 1),
}
cart = ShoppingCart(items)
cart.checkout(item_id=1, quantity=10, expected_version=1)
cart.checkout(item_id=1, quantity=10, expected_version=1) # 应该失败悲观锁的实际应用案例
假设有一个在线银行系统，用户可以查询和转账账户余额。在转账时，需要确保账户余额不会被其他操作修改过。
import threading
class Account:
def __init__(self, balance):
self.balance = balance
self.lock = threading.Lock()
def transfer(self, amount):
with self.lock:
if self.balance >= amount:
self.balance -= amount
print(f"Transferred {amount}, remaining balance: {self.balance}.")
else:
raise Exception("Insufficient balance.")
account = Account(balance=1000)
thread1 = threading.Thread(target=account.transfer, args=(500,))
thread2 = threading.Thread(target=account.transfer, args=(600,))
thread1.start()
thread2.start()
thread1.join()
thread2.join()为了更好地理解和应用乐观锁和悲观锁，我们再来看一个涉及多线程环境下的实际应用案例。假设有一个多线程环境下的任务管理器，管理员可以同时分配和取消任务。在分配任务时，需要确保任务的状态没有被其他操作修改过。
import threading
class TaskManager:
def __init__(self):
self.tasks = {
1: {"name": "Task 1", "status": "pending", "version": 1},
2: {"name": "Task 2", "status": "pending", "version": 1}
}
self.lock = threading.Lock()
def assign_task(self, task_id, new_status, expected_version):
task = self.tasks.get(task_id)
if task is None:
raise Exception("Task not found.")
if task['version'] != expected_version:
raise Exception("Task has been updated by another transaction.")
task['status'] = new_status
task['version'] += 1
print(f"Assigned task {task_id} to {new_status} with version {task['version']}.")
task_manager = TaskManager()
thread1 = threading.Thread(target=task_manager.assign_task, args=(1, "assigned", 1))
thread2 = threading.Thread(target=task_manager.assign_task, args=(2, "assigned", 1))
thread1.start()
thread2.start()
thread1.join()
thread2.join()通过以上案例，我们可以看到乐观锁和悲观锁在实际项目中的具体应用。乐观锁适用于并发操作较少的场景，而悲观锁适用于并发操作频繁且需要保证数据一致性的场景。选择合适的锁机制能够更好地满足业务需求，提高系统的性能和稳定性。
點擊查看更多內容
為 TA 點贊
評論
評論
共同學習，寫下你的評論
評論加載中...
作者其他優質文章
正在加載中
感謝您的支持，我會繼續努力的～
掃碼打賞，你說多少就多少
贊賞金額會直接到老師賬戶
支付方式
打開微信掃一掃，即可進行掃碼打賞哦