悲观锁与乐观锁

最新推荐文章于 2025-06-08 17:05:25 发布
最新推荐文章于 2025-06-08 17:05:25 发布
阅读量1.2k 收藏 13
点赞数 31
CC 4.0 BY-SA版权
分类专栏： java 进阶知识点 文章标签： 锁 乐观锁 悲观锁 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43841461/article/details/142855933

目录

悲观锁与乐观锁的概念

悲观锁

乐观锁

悲观锁的实现

synchronized 关键字

ReentrantLock 类

乐观锁的实现

版本号机制

CAS 操作

悲观锁与乐观锁的区别

锁机制

性能

适用场景

示例对比

悲观锁示例

乐观锁示例

性能测试

测试结果分析

总结

在多线程编程中，锁机制是确保数据一致性和线程安全的关键技术。悲观锁和乐观锁是两种常见的锁机制，它们在不同的场景下有着各自的优势和适用范围。本文将详细介绍悲观锁和乐观锁的区别，并通过 Java 代码示例展示它们的使用方法。

悲观锁与乐观锁的概念

悲观锁

悲观锁（Pessimistic Locking）假设在并发环境中会发生冲突，因此在访问共享资源时总是先加锁，确保在事务期间没有其他线程可以修改该资源。悲观锁在事务开始时就获取锁，直到事务结束时才释放锁。

乐观锁

乐观锁（Optimistic Locking）假设在并发环境中很少发生冲突，因此在访问共享资源时不立即加锁，而是等到真正需要修改资源时再检查是否有冲突。如果发现冲突，则采取补偿措施（如重试或回滚）。

悲观锁的实现

synchronized 关键字

synchronized 关键字是 Java 中最基本的悲观锁实现方式。它可以用于方法或代码块，确保同一时间只有一个线程可以执行被同步的代码。

public class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized void decrement() {
        count--;
    }

    public synchronized int getCount() {
        return count;
    }
}
ReentrantLock 类

ReentrantLock 类提供了比 synchronized 更灵活的锁机制。它可以显式地获取和释放锁，并支持公平锁和非公平锁。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Counter {
    private int count = 0;
    private final Lock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public void decrement() {
        lock.lock();
        try {
            count--;
        } finally {
            lock.unlock();
        }
    }

    public int getCount() {
        lock.lock();
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }
}

乐观锁的实现

版本号机制

版本号机制的基本思路是在数据中增加一个字段version，表示该数据的版本号，每当数据被修改，版本号加1。

当某个线程查询数据时，将该数据的版本号一起查出来；

当该线程更新数据时，判断当前版本号与之前读取的版本号是否一致，如果一致才进行操作。

需要注意的是，这里使用了版本号作为判断数据变化的标记，实际上可以根据实际情况选用其他能够标记数据版本的字段，如时间戳等。

 下面以“更新玩家金币数”为例（数据库为MySQL，其他数据库同理），看看悲观锁和版本号机制是如何应对并发问题的。

考虑这样一种场景：游戏系统需要更新玩家的金币数，更新后的金币数依赖于当前状态(如金币数、等级等)，因此更新前需要先查询玩家当前状态。

下面的实现方式，没有进行任何线程安全方面的保护。如果有其他线程在query和update之间更新了玩家的信息，会导致玩家金币数的不准确。

@Transactional
public void updateCoins(Integer playerId){
    //根据player_id查询玩家信息
    Player player = query("select coins, level from player where player_id = {0}", playerId);
    //根据玩家当前信息及其他信息，计算新的金币数
    Long newCoins = ……;
    //更新金币数
    update("update player set coins = {0} where player_id = {1}", newCoins, playerId);
}

为了避免这个问题，悲观锁通过加锁解决这个问题，代码如下所示。在查询玩家信息时，使用select …… for update进行查询；

该查询语句会为该玩家数据加上排它锁，直到事务提交或回滚时才会释放排它锁；

在此期间，如果其他线程试图更新该玩家信息或者执行select for update，会被阻塞。

@Transactional
public void updateCoins(Integer playerId){
    //根据player_id查询玩家信息（加排它锁）
    Player player = queryForUpdate("select coins, level from player where player_id = {0} for update", playerId);
    //根据玩家当前信息及其他信息，计算新的金币数
    Long newCoins = ……;
    //更新金币数
    update("update player set coins = {0} where player_id = {1}", newCoins, playerId);
}

 版本号机制则是另一种思路，它为玩家信息增加一个字段：version。在初次查询玩家信息时，同时查询出version信息；

在执行update操作时，校验version是否发生了变化，如果version变化，则不进行更新。

@Transactional
public void updateCoins(Integer playerId){
    //根据player_id查询玩家信息，包含version信息
    Player player = query("select coins, level, version from player where player_id = {0}", playerId);
    //根据玩家当前信息及其他信息，计算新的金币数
    Long newCoins = ……;
    //更新金币数，条件中增加对version的校验
    int rowsUpdated =update("update player set coins = {0} where player_id = {1} and version = {2}", newCoins, playerId, player.version);
    if (rowsUpdated == 0) {
        throw new OptimisticLockException("Data has been modified by another transaction");
     }
}
CAS 操作

原子操作（如 compareAndSet）是另一种常见的乐观锁实现方式。Java 提供了 AtomicInteger 类，支持 CAS 操作。

import java.util.concurrent.atomic.AtomicInteger;

public class OptimisticCounter {
    private AtomicInteger count = new AtomicInteger(0);

    public void increment() {
        int current;
        int next;
        do {
            current = count.get();
            next = current + 1;
        } while (!count.compareAndSet(current, next));
    }

    public void decrement() {
        int current;
        int next;
        do {
            current = count.get();
            next = current - 1;
        } while (!count.compareAndSet(current, next));
    }

    public int getCount() {
        return count.get();
    }
}

悲观锁与乐观锁的区别

锁机制
  • 悲观锁：在访问共享资源时总是先加锁，确保在事务期间没有其他线程可以修改该资源。
  • 乐观锁：在访问共享资源时不立即加锁，而是等到真正需要修改资源时再检查是否有冲突。
性能
  • 悲观锁：由于总是加锁，可能会导致线程阻塞，影响性能。
  • 乐观锁：只有在真正需要修改资源时才检查冲突，减少了不必要的锁竞争，提高了性能。
适用场景
  • 悲观锁：适用于写操作多于读操作的场景，或者对数据一致性要求极高的场景。
  • 乐观锁：适用于读操作多于写操作的场景，或者冲突概率较低的场景。

示例对比

悲观锁示例
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class PessimisticCounter {
    private int count = 0;
    private final Lock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public void decrement() {
        lock.lock();
        try {
            count--;
        } finally {
            lock.unlock();
        }
    }

    public int getCount() {
        lock.lock();
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }
}
乐观锁示例
import java.util.concurrent.atomic.AtomicInteger;

public class OptimisticCounter {
    private AtomicInteger count = new AtomicInteger(0);

    public void increment() {
        int current;
        int next;
        do {
            current = count.get();
            next = current + 1;
        } while (!count.compareAndSet(current, next));
    }

    public void decrement() {
        int current;
        int next;
        do {
            current = count.get();
            next = current - 1;
        } while (!count.compareAndSet(current, next));
    }

    public int getCount() {
        return count.get();
    }
}

性能测试

为了对比悲观锁和乐观锁的性能，我们可以编写一个简单的测试程序。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class LockPerformanceTest {

    public static void main(String[] args) throws InterruptedException {
        testPessimisticLock();
        testOptimisticLock();
    }

    public static void testPessimisticLock() throws InterruptedException {
        PessimisticCounter counter = new PessimisticCounter();
        ExecutorService executor = Executors.newFixedThreadPool(10);

        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            executor.submit(counter::increment);
        }
        executor.shutdown();
        executor.awaitTermination(1, TimeUnit.MINUTES);

        long end = System.currentTimeMillis();
        System.out.println("Pessimistic Lock Time: " + (end - start) + " ms");
        System.out.println("Final Count: " + counter.getCount());
    }

    public static void testOptimisticLock() throws InterruptedException {
        OptimisticCounter counter = new OptimisticCounter();
        ExecutorService executor = Executors.newFixedThreadPool(10);

        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            executor.submit(counter::increment);
        }
        executor.shutdown();
        executor.awaitTermination(1, TimeUnit.MINUTES);

        long end = System.currentTimeMillis();
        System.out.println("Optimistic Lock Time: " + (end - start) + " ms");
        System.out.println("Final Count: " + counter.getCount());
    }
}

测试结果分析

通过运行上述测试程序，我们可以观察到悲观锁和乐观锁在不同场景下的性能表现。一般来说：

  • 悲观锁：由于总是加锁，可能会导致线程阻塞，特别是在写操作频繁的场景下，性能较差。
  • 乐观锁：只有在真正需要修改资源时才检查冲突，减少了不必要的锁竞争，提高了性能，特别是在读操作多于写操作的场景下表现更好。

总结

悲观锁和乐观锁是两种常见的锁机制，它们在不同的场景下有着各自的优势和适用范围。悲观锁适用于写操作多于读操作的场景，或者对数据一致性要求极高的场景。乐观锁适用于读操作多于写操作的场景，或者冲突概率较低的场景。

通过本文的学习，希望读者能够更好地理解和选择合适的锁机制，以提高多线程程序的性能和可靠性。如果您有任何疑问或建议，请随时留言交流。

悲观锁与乐观锁的实现(详情图解)含面试专题及答案
m0_67322837的博客
04-08 1030
一、前言 在了解悲观锁和乐观锁之前，我们先了解一下什么是锁，为什么要用到锁？ 技术来源于生活，锁不仅在程序中存在，在现实中我们也随处可见，例如我们上下班打卡的指纹锁，保险柜上的密码锁，以及我们我们登录的用户名和密码也是一种锁，生活中用到锁可以保护我们人身安全（指纹锁）、财产安全（保险柜密码锁）、信息安全（用户名密码锁），让我们更放心的去使用和生活，因为有锁，我们不用去担心个人的财产和信息泄露。 而程序中的锁，则是用来保证我们数据安全的机制和手段，例如当我们有多个线程去访问修改共享变量的时候，我们可以给
乐观锁
weixin_42165130的博客
12-08 681
乐观锁介绍： 乐观锁（ Optimistic Locking ） 相对悲观锁而言，乐观锁假设认为数据一般情况下不会造成冲突，所以在数据进行提交更新的时候，才会正式对数据的冲突与否进行检测，如果发现冲突了，则让返回用户错误的信息，让用户决定如何去做。那么我们如何实现乐观锁呢，一般来说有以下2种方式： 1、使用版本号实现乐观锁 版本号的实现方式有两种，一个是数据版本机制，一个是时间戳机制。具体如下。 a.使用数据版本（Version）记录机制实现，这是乐观锁最常用的一种实现方式。何谓数据版本？即为数据增
乐观锁与悲观锁
tianjinsong的专栏
11-02 4719
http://www.jianshu.com/p/59ddb7002b30 首先我们理解下两种不同思路的锁，乐观锁和悲观锁。 这两种锁机制，是在多用户环境并发控制的两种所机制。下面看百度百科对乐观锁和悲观锁两种锁机制的定义： 乐观锁（ Optimistic Locking ） 相对悲观锁而言，乐观锁机制采取了更加宽松的加锁机制。悲观锁大多数情况下依靠数据库的锁机制实现，以保证操作最大
【java】乐观锁的实现和注意细节
最新发布
qq_42320804的博客
06-08 973
java 乐观锁的实现和注意细节
悲观锁和乐观锁详解
qq_53793319的博客
07-28 9510
乐观锁和悲观锁是并发控制的一种机制，用于多线程或多进程环境下对共享资源的访问管理，以防止数据不一致或竞态条件。它们的主要区别在于对待冲突的策略。
MySQL中的悲观锁与乐观锁
01-21
在关系型数据库中，悲观锁与乐观锁是解决资源并发场景的解决方案，接下来将详细讲解:magnifying_glass_tilted_right:一下这两个并发解决方案的实际使用及优缺点。 首先定义一下数据库，做一个最简单的库存表，如下...
mysql 悲观锁与乐观锁的理解及应用分析
12-14
本文实例讲述了mysql 悲观锁与乐观锁。分享给大家供大家参考，具体如下： 悲观锁与乐观锁是人们定义出来的概念，你可以理解为一种思想，是处理并发资源的常用手段。 不要把他们与mysql中提供的锁机制(表锁，行锁，...
Java Day21
qq_51944132的博客
10-12 114
所谓的乐观锁，其实主要就是一种思想，因为乐观锁的操作过程中其实没有没有任何锁的参与，乐观锁只是和悲观锁相对，严格的说乐观锁不能称之为锁。所以要了解乐观锁的概念，通常与悲观锁对比起来看才更好理解，下面我们就通过乐观锁与悲观锁的对比来更好的理解乐观锁。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值