详解悲观锁

最新推荐文章于 2025-03-27 09:22:54 发布
最新推荐文章于 2025-03-27 09:22:54 发布
阅读量912 收藏 10
点赞数 11
分类专栏： java锁机制 文章标签： java spring
希望能够帮助到你，麻烦给个关注和点赞
本文链接：https://blog.youkuaiyun.com/m0_67694272/article/details/145399390
版权

Java 中悲观锁的概念与实现方式

1. 悲观锁的概念

悲观锁（Pessimistic Locking）是一种并发控制机制，它假设在并发环境中，数据冲突是不可避免的，因此在操作共享资源时，总是先加锁，确保其他线程在锁释放前无法访问或修改该资源。悲观锁适合在高并发且数据冲突频繁的场景中使用。

2. 悲观锁的实现方式

2.1 使用 synchronized 关键字

synchronized 是 Java 中最常用的悲观锁实现方式，用于对代码块或方法进行同步，确保同一时间只有一个线程可以执行被锁定的代码。

实现步骤：

  1. 同步代码块：

    java复制

    public class PessimisticLockExample {
    private Object lock = new Object();

    public void updateData() {
        synchronized (lock) {
            // 被锁定的代码块
            System.out.println("Updating data...");
        }
    }
}

  2. 同步方法：

    java复制

    public class PessimisticLockExample {
    public synchronized void updateData() {
        // 整个方法被锁定
        System.out.println("Updating data...");
    }
}
优点：
  • 简单易用：Java 内置支持，代码简洁。
  • 自动释放锁：异常或方法结束时会自动释放锁。
缺点：
  • 性能问题：锁的粒度较大时，可能导致性能瓶颈。
  • 死锁风险：不当使用可能导致死锁。

2.2 使用 ReentrantLock 类

ReentrantLock 是 Java 提供的显式锁，相较于 synchronized，它提供了更多的功能，如尝试锁、非阻塞锁、公平锁等。

实现步骤：

  1. 创建锁对象：

    java复制

    import java.util.concurrent.locks.ReentrantLock;

public class PessimisticLockExample {
    private ReentrantLock lock = new ReentrantLock();

    public void updateData() {
        lock.lock(); // 获取锁
        try {
            // 被锁定的代码块
            System.out.println("Updating data...");
        } finally {
            lock.unlock(); // 确保释放锁
        }
    }
}

  2. 尝试获取锁：

    java复制

    if (lock.tryLock()) {
    try {
        // 被锁定的代码块
        System.out.println("Updating data...");
    } finally {
        lock.unlock();
    }
} else {
    System.out.println("Failed to acquire lock");
}
优点：
  • 灵活性高：支持可中断锁、尝试锁、公平锁等。
  • 功能丰富：可以更精细地控制锁的行为。
缺点：
  • 手动释放锁：需要显式调用 unlock()，否则可能导致死锁。
  • 代码复杂性：相较于 synchronized，实现稍显复杂。

2.3 使用数据库的悲观锁机制

在数据库层面，可以通过 SELECT ... FOR UPDATE 或 SELECT ... FOR SHARE 语句实现悲观锁，确保数据在事务提交前不会被其他事务修改。

实现步骤：

  1. 使用 SELECT ... FOR UPDATE：

    sql复制

    -- 查询数据并加锁
SELECT * FROM tb_voucher_order WHERE voucher_id = 1 FOR UPDATE;

  2. 更新数据：

    sql复制

    -- 更新数据
UPDATE tb_voucher_order SET stock = stock - 1 WHERE voucher_id = 1;

  3. Java 实现：

    java复制

    @Transactional
public void updateVoucherOrder(Long voucherId) {
    // 使用 FOR UPDATE 查询
    SeckillVoucher voucher = seckillVoucherService.getForUpdateById(voucherId);

    // 扣减库存
    voucher.setStock(voucher.getStock() - 1);
    seckillVoucherService.save(voucher);

    // 创建订单
    VoucherOrder voucherOrder = new VoucherOrder();
    voucherOrder.setUserId(UserHolder.getUser().getId());
    voucherOrder.setVoucherId(voucherId);
    voucherOrder.save();
}
优点：
  • 强一致性：确保数据在事务提交前不会被其他事务修改。
  • 简单易用：直接利用数据库的锁机制。
缺点：
  • 性能问题：在高并发场景下，可能导致数据库锁等待时间过长。
  • 死锁风险：不当使用可能导致死锁。

2.4 使用 Lock 接口的其他实现类

除了 ReentrantLock，Java 还提供了其他锁实现类，如 ReadWriteLock 和 StampedLock。

2.4.1 使用 ReadWriteLock

ReadWriteLock 支持读写分离，允许多个读操作同时进行，但写操作时会独占锁。

实现步骤：

  1. 创建锁对象：

    java复制

    import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class PessimisticLockExample {
    private ReadWriteLock lock = new ReentrantReadWriteLock();

    public void updateData() {
        lock.writeLock().lock(); // 获取写锁
        try {
            System.out.println("Updating data...");
        } finally {
            lock.writeLock().unlock();
        }
    }

    public void readData() {
        lock.readLock().lock(); // 获取读锁
        try {
            System.out.println("Reading data...");
        } finally {
            lock.readLock().unlock();
        }
    }
}
优点：
  • 读写分离：允许多个读操作同时进行，提高并发性能。
  • 适合读多写少的场景：如查询多、更新少的业务。
缺点：
  • 复杂性：实现和使用相对复杂。

2.4.2 使用 StampedLock

StampedLock 是 Java 8 引入的一种乐观锁和悲观锁结合的锁实现，支持读、写和乐观读模式。

实现步骤：

  1. 创建锁对象：

    java复制

    import java.util.concurrent.locks.StampedLock;

public class PessimisticLockExample {
    private StampedLock lock = new StampedLock();

    public void updateData() {
        long stamp = lock.writeLock(); // 获取写锁
        try {
            System.out.println("Updating data...");
        } finally {
            lock.unlockWrite(stamp);
        }
    }

    public void readData() {
        long stamp = lock.readLock(); // 获取读锁
        try {
            System.out.println("Reading data...");
        } finally {
            lock.unlockRead(stamp);
        }
    }
}
优点：
  • 高性能：结合了悲观锁和乐观锁的优点。
  • 灵活性：支持多种锁模式。
缺点：
  • 复杂性：实现和使用相对复杂。

2.5 使用分布式锁

在分布式系统中，可以使用 ZooKeeper 或 Redis 实现悲观锁。

2.5.1 使用 Redis 实现分布式锁

java复制

public class DistributedLockExample {
    private RedisTemplate<String, String> redisTemplate;

    public boolean acquireLock(String lockKey) {
        // 尝试获取锁
        String lockValue = UUID.randomUUID().toString();
        Boolean success = redisTemplate.opsForValue().setIfAbsent(lockKey, lockValue, 10, TimeUnit.SECONDS);
        return success != null && success;
    }

    public void releaseLock(String lockKey, String lockValue) {
        // 获取当前锁的值
        String currentValue = redisTemplate.opsForValue().get(lockKey);
        if (currentValue != null && currentValue.equals(lockValue)) {
            // 释放锁
            redisTemplate.delete(lockKey);
        }
    }
}

2.5.2 使用 ZooKeeper 实现分布式锁

java复制

public class DistributedLockExample {
    private CuratorFramework client;

    public void acquireLock(String lockPath) throws Exception {
        InterProcessMutex lock = new InterProcessMutex(client, lockPath);
        lock.acquire();
    }

    public void releaseLock(String lockPath) throws Exception {
        InterProcessMutex lock = new InterProcessMutex(client, lockPath);
        lock.release();
    }
}
优点：
  • 分布式支持：适用于分布式系统。
  • 高一致性：确保分布式环境下的数据一致性。
缺点：
  • 依赖外部服务：需要依赖 ZooKeeper 或 Redis 等外部服务。
  • 复杂性：实现和维护成本较高。

总结

悲观锁的实现方式多样，可以根据具体需求选择合适的方式：

  • synchronized：简单易用，适合单线程环境。
  • ReentrantLock：功能丰富，适合需要更多控制的场景。
  • 数据库锁：直接利用数据库的锁机制，适合数据一致性要求高的场景。
  • 分布式锁：适用于分布式系统，确保数据一致性。
悲观锁与乐观锁详解+synchronized vs ReentrantLock
秉持长期主义，保持长期生命力和竞争力
03-26 898
聊一聊锁机制
悲观锁的实现方式java_并发编程--锁--悲观锁和乐观锁
weixin_30920223的博客
02-28 5132
悲观锁和乐观锁并不是某个具体的“锁”而是一种并发编程的基本概念，是根据看待并发同步的角度。乐观锁和悲观锁最早出现在数据库的设计当中，后来逐渐被 Java 的并发包所引入。悲观锁悲观锁认为对于同一个数据的并发操作一定是会发生修改的，采取加锁的形式，悲观地认为，不加锁的并发操作一定会出问题。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。Java中...
Java 中的悲观锁和乐观锁的实现
08-11
Java 中的悲观锁和乐观锁的实现 纯开发技巧。
悲观锁与乐观锁的实现(详情图解)
热门推荐
牧小农
05-27 3万+
一、前言 在了解悲观锁和乐观锁之前，我们先了解一下什么是锁，为什么要用到锁？ 技术来源于生活，锁不仅在程序中存在，在现实中我们也随处可见，例如我们上下班打卡的指纹锁，保险柜上的密码锁，以及我们我们登录的用户名和密码也是一种锁，生活中用到锁可以保护我们人身安全（指纹锁）、财产安全（保险柜密码锁）、信息安全（用户名密码锁），让我们更放心的去使用和生活，因为有锁，我们不用去担心个人的财产和信息泄露。 而程序中的锁，则是用来保证我们数据安全的机制和手段，例如当我们有多个线程去访问修改共享变量的时候，我们
MySQL 锁机制全面解析：乐观锁与悲观锁实现及深度剖析
最新发布
jakeswang的博客
03-27 1275
锁选择原则读多写少 → 乐观锁写多读少 → 悲观锁跨服务操作 → 分布式锁+Saga性能优化技巧减小锁粒度（行锁而非表锁）缩短锁持有时间（避免事务中包含RPC调用）添加合理的重试机制避免常见陷阱乐观锁的重试次数不宜过多（通常3次）悲观锁必须按固定顺序获取分布式锁必须设置超时时间通过以上实际场景的深度分析，可以看出没有放之四海而皆准的锁方案，必须根据具体业务特点、并发规模和数据一致性要求来选择最合适的并发控制策略。
悲观锁实现
doffq1920的博客
08-21 197
SELECT * FROM 表名 WHERE 条件 .... FOR UPDATE 开启锁 update .......................... 释放锁 转载于:https://www.cnblogs.com/Tomlin/p/9509150.html
JAVA并发编程（五）乐观锁 悲观锁
QuinnNorris的博客
02-07 964
悲观锁 认为随时有可能发生冲突，用锁保护所有临界区。日常使用的锁绝大多数都是悲观锁。 优点： 1. 确保安全性，悲观锁临界区内不会发生并发问题。 2. 简单方便。 3. 使用悲观锁，在临界区内操作数据成功率高。 缺点： 1. 如果临界区内耗时长，会影响程序整体工作效率。 2. 可能产生死锁。 乐观锁 乐观的认为不会发生并发冲突，不为临界区代码加锁，但会持有在运行临界
悲观锁实现与原理
m0_74267125的博客
10-25 988
同步器的设计是基于模板方法模式，该模式是基于继承的，主要是为了在不改变模板结构的前提下在子类中重新定义模板中的内容以实现复用代码使用者继承并重写指定的方法将 AQS 组合在自定义同步组件的实现中，并调用其模板方法，这些模板方法会调用使用者重写的方法AQS 使用了模板方法模式，自定义同步器时需要重写下面几个 AQS 提供的模板方法（钩子方法isHeldExclusively() //该线程是否正在独占资源。只有用到condition才需要去实现它tryAcquire(int) //独占方式。
[数据库事务与锁]详解七 深入理解乐观锁与悲观锁
11-28
#### 二、悲观锁详解 **1. 基本概念** 悲观锁是一种较为保守的并发控制方法，它假设数据访问会发生冲突，因此在整个数据处理过程中将数据锁定。这种锁定机制通常依赖于数据库本身的锁机制来实现，比如行锁、表锁等...
基于Django的乐观锁与悲观锁解决订单并发问题详解
09-18
本文将深入探讨如何使用Django框架中的乐观锁和悲观锁机制来解决订单并发问题，确保数据的一致性和准确性。 首先，我们需要了解什么是事务。在数据库管理中，事务是一组操作，这些操作要么全部成功，要么全部失败。...
面试必备之乐观锁与悲观锁.pdf
03-11
### 面试必备之乐观锁与悲观锁详解 #### 一、悲观锁与乐观锁的概念 悲观锁和乐观锁是计算机科学中用于处理并发控制的两种不同策略，它们主要应用于多线程环境下数据的一致性和完整性保护。两种锁的设计哲学反映了...
悲观锁和乐观锁的具体实现方式
qq_42697271的博客
08-27 2387
最近上了一节秒杀实战课，里面讲了一些高并发情况下的事故处理方案，笔者在此记录一下 目录一、悲观锁的实现方式注意事项二、乐观锁的实现方式 一、悲观锁的实现方式 悲观锁表明的是用户对他的每次操作都觉得会有其他用户同时进行操作，导致数据出现问题，此时悲观锁会在用户操作时将表锁住，让其他的用户不能对该条进行任何操作，具体实现如下： select * from product where id = 1 for update; 使用了for update之后就会自动将该条数据锁定，其他用户无法对该条数据进.
悲观锁的实现
bin_lhb的博客
01-15 2150
悲观锁(数据库提供实现) . 默认认为一定发生别人要修改我使用的数据. 那我就可以为我读取的数据加锁. iselect * from table for update （写锁、排它锁） Hibernate 如何来实现 i. get（Object,int,LockOption）方法设置读取模式 session.get(Customer.class, 5, LockOptions.UPGRAD
面试官问的最多的 乐观锁，悲观锁，可重入锁等 到底是什么，怎么实现？
m0_71777195的博客
08-11 1676
然后，我们创建了两个线程，在涉及到共享数据的代码块中分别调用 lock() 方法获取锁，并在修改共享数据后调用 unlock() 方法释放锁。然后，我们创建了两个线程，在涉及到共享数据的代码块中分别调用 lock() 方法获取锁，并在修改共享数据后调用 unlock() 方法释放锁。在示例中，当线程1获取到锁后，在修改共享数据期间又调用了 updateSharedData() 方法，该方法中也需要获取锁。在公平锁中，当多个线程竞争同一个锁时，锁会按照线程等待的顺序分配给它们。
看完你就应该能明白的悲观锁和乐观锁
JAVA葵花宝典
09-27 195
Java 按照锁的实现分为乐观锁和悲观锁，乐观锁和悲观锁并不是一种真实存在的锁，而是一种设计思想，乐观锁和悲观锁对于理解 Java 多线程和数据库来说至关重要，那么本篇文...
5 悲观锁实现_InnoDB 悲观锁实现
weixin_39678493的博客
01-13 407
InnoDB中的select .. for update语句：1)select .. for update语句仅适用于InnoDB2)select .. for update语句必须在事务中才能生效。3)在执行事务中的select .. for update语句时，MySQL会对查询结果集中的每行数据都添加排他锁(行锁、表锁)，其它线程对锁定行的 更新、删除、select .. for updat...
乐观锁，悲观锁实现步骤
qq_38989173的博客
07-13 1822
共享锁：可多事务或非事务同时查询当前数据【如果有一个事务在查询后，执行了增删改语句，则数据锁定（自动追加排它锁），不再允许其他事务查询，直到事务结束为止】乐观锁认为本次操作不会导致冲突，所以不进行任何其他特殊处理，在更新后【如果冲突，更新不会成功，如果不冲突，则更新成功】再去判断是否冲突。2：执行程序，修改当前条目【update字段：更新数据，版本号加1；排它锁：只能由一个事务操作当前数据【加锁后，其他事务无法实现以下操作（行级锁：删改查操作，表级锁：增删改查）】1：乐观锁：（行级）实现：共享锁，排它锁。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值