乐观锁和悲观锁

最近被问到这个东西，所以查找一下资料然后自己归纳总结一下这两个东西。

乐观锁

概念：乐观锁假设并发冲突不常发生，允许多个事务同时访问数据，但在提交时检查数据是否被修改过（个人认为就是最后检查一下是否某个值比如id或版本，来判定是否有人修改了资料，有就不允许其他事务操作了 ）
一般通过某个标识来判定资料是否被异动

1. 版本号机制

// 实体类
public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
    public int Version { get; set; } // 版本号字段
}


// 更新时检查版本
UPDATE Products 
SET Name = @NewName, Price = @NewPrice, Version = Version + 1 
WHERE Id = @Id AND Version = @OriginalVersion

2. 时间戳机制

public class Order
{
    public int Id { get; set; }
    public DateTime Timestamp { get; set; } // 时间戳字段
}

// SQL
UPDATE Orders 
SET Status = @NewStatus, Timestamp = GETDATE() 
WHERE Id = @Id AND Timestamp = @OriginalTimestamp

事例：

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    [Timestamp] // 使用时间戳作为乐观锁
    public byte[] RowVersion { get; set; }
}

// 更新时处理并发冲突
try
{
    var product = context.Products.Find(id);
    product.Name = "New Name";
    context.SaveChanges();
}
catch (DbUpdateConcurrencyException ex)
{
    // 处理冲突
    var entry = ex.Entries[0];
    var databaseValues = entry.GetDatabaseValues();
    // 决定如何处理（重试/合并/取消）
}

最后UPDATE时判定是否通过刚开始查询出来的标识带入到UPDATE条件看是否会有影响行，来判定资料是有有给人异动( 更新失败后考虑是否要加入重试机制或人员手动触发按钮，捞取最新资料再次进行资料异动)

悲观锁

概念:悲观锁假设并发冲突经常发生，在访问数据前先加锁，阻止其他事务访问（个人认为就是最开始就认定他会被改，只允许一个人改，加了个锁后，其他人就不能直接访问，有点像同步锁的概念 ）

实现方式

1. 数据库行锁（注意加了行锁之后，需要事务commit，rockback才会释放）

-- SQL Server
BEGIN TRANSACTION
SELECT * FROM Products WITH (UPDLOCK) WHERE Id = 1
-- 执行更新操作
UPDATE Products SET Stock = Stock - 1 WHERE Id = 1
COMMIT TRANSACTION

2. C# 代码实现

// 使用锁对象
private static readonly object _lockObj = new object();

public void UpdateProduct(int productId)
{
    lock (_lockObj)
    {
        // 执行更新操作
    }
}

事例

using (var connection = new SqlConnection(connectionString))
{
    connection.Open();
    using (var transaction = connection.BeginTransaction())
    {
        try
        {
            // 获取悲观锁
            var cmd = connection.CreateCommand();
            cmd.Transaction = transaction;
            cmd.CommandText = "SELECT * FROM Accounts WITH (UPDLOCK) WHERE Id = @id";
            cmd.Parameters.AddWithValue("@id", accountId);
            var reader = cmd.ExecuteReader();
            
            // 执行更新操作
            if (reader.Read())
            {
                var updateCmd = connection.CreateCommand();
                updateCmd.Transaction = transaction;
                updateCmd.CommandText = "UPDATE Accounts SET Balance = Balance - @amount WHERE Id = @id";
                updateCmd.Parameters.AddWithValue("@id", accountId);
                updateCmd.Parameters.AddWithValue("@amount", amount);
                updateCmd.ExecuteNonQuery();
            }
            
            transaction.Commit();
        }
        catch
        {
            transaction.Rollback();
            throw;
        }
    }
}

悲观锁保证了事务的强一致性，但是有可能会导致死锁的现象，需要注意

在实际应用中，可以结合两种锁策略：

// 先尝试乐观锁
try
{
    OptimisticUpdate();
}
catch (ConcurrencyException)
{
    // 如果乐观锁失败，使用悲观锁重试
    PessimisticUpdate();
}

总结：

乐观锁与悲观锁核心区别对比表（C#实现示例）

补充说明：

• 悲观锁C#示例：使用lock关键字确保代码块原子性

  private readonly object _lockObj = new object();
  
  public void UpdateData()
  {
      lock (_lockObj)  // 加锁
      {
          // 执行数据更新操作
      }
  }
  

• 乐观锁C#示例：使用Interlocked类（CAS操作）

  private int _counter = 0;
  
  public void IncrementCounter()
  {
      int original, newValue;
      do
      {
          original = _counter;
          newValue = original + 1;
          // 比较并交换：如果当前值等于original，则更新为newValue
      } while (Interlocked.CompareExchange(ref _counter, newValue, original) != original);
  }
  ```   |