乐观锁和悲观锁的应用（Java应用向）

ouy灬lzq

已于 2025-03-25 20:52:32 修改

阅读量1.5k

点赞数 44

文章标签： java 开发语言

于 2025-03-25 20:51:56 首次发布

本文链接：https://blog.youkuaiyun.com/qq_64174887/article/details/146504841

版权

一、两种锁的原理

悲观锁原理：

在修改数据之前将其锁定，并在操作完成后释放锁定，以确保数据的一致性和完整性。

乐观锁原理：

不加锁直接进行操作，但在更新数据时会进行版本比对，版本对应时才能更新，不对应则放弃更新，以确保数据的一致性。

本质区别：

悲观锁是线程阻塞的形式实现的，乐观锁的线程没有被阻塞，更像是一种权限的认证。

二、悲观锁的实现

2.1 synchronized关键字修饰

先介绍下synchronized，这是Java原生的关键字，不是某个包，因此源码我也找不到很多（博主很菜，勿喷）。

synchronized可以用于以下3种情景：

2.1.1. 修饰实例方法

你只要记住，修饰实例方法其实锁的是该对象，用简单的话解释就是：

该实例有一把锁，要想运行这个方法，需要拿到实例的锁（这锁是唯一的，监视器锁 monitor）。

例如：

线程1执行methodA()时，要获取example的锁，之后这个唯一的锁就被线程1占用了

线程2执行的不是methodA()而是methodB()，因此不用借example的锁，可以直接运行。

线程3不知好歹，也要执行methodA()，但这时example的锁已经被线程1占用了，线程3只能等待线程1执行完释放锁，它再来获取锁，才能执行methodA()

public class SynchronizedExample {
    public synchronized void methodA() {
        System.out.println("线程A");
    }

    public void methodB() {
        System.out.println("线程B");
    }

    public static void main(String[] args) {
        SynchronizedExample example = new SynchronizedExample();

        // 线程 1 执行 methodA
        Thread t1 = new Thread(() -> example.methodA(), "Thread-1");

        // 线程 2 执行 methodB
        Thread t2 = new Thread(() -> example.methodB(), "Thread-2");
        
        // 线程 3 也要执行 methodA
        Thread t3 = new Thread(() -> example.methodA(), "Thread-3");

        t1.start();// 正常运行
        t2.start();// 正常运行
        t3.start();// 等待t1完成后才能执行methodA()
    }
}

2.1.2 修饰静态方法

同样只用记住: 修饰静态方法其实锁的是该类，用简单的话解释就是：

该类有一把锁，要想运行这个方法，需要拿到类的锁（这锁是唯一的，监视器锁 monitor）。

例如:

依次启动5个线程执行被修饰的静态方法updateSharedResource()

只有一个线程可以拿到SynchronizdExample类的监视锁

其他4个线程先阻塞

等拿到锁的线程释放后才能请求获得锁 (等待的线程是用集合存储的,无顺序,因此是非公平锁)

class SynchronizedExample {
    private static int count= 0;

    // synchronized修饰的静态方法
    public static synchronized void updateSharedResource() {
        count++;
        System.out.println("Shared resource value: " + sharedResource);
    }
}

public class LockExample {
    public static void main(String[] args) {
        // 多线程并发调用静态方法
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                SynchronizedExample.updateSharedResource();
            }).start();
        }
    }
}

注意这两种锁不是互斥的,因为对象monitor和类monitor没有直接关系

2.1.3. 修饰代码块

虽然是修饰代码块,但本质还是对类或实例的锁.原理不再讲,同上,用法:

synchronized ( 类/实例 ) {
执行前要获取类/实例的代码
}

以下程序进行到counter++时才会获取实例锁,打印Doing some non-critical work...时不需要

public class SynchronizeExample {
    private int counter = 0;

    public void increment() {
        // 不需要同步的代码
        System.out.println("Doing some non-critical work...");

        // 需要同步的代码
        synchronized (this) {
            counter++;
        }
    }

    public int getCounter() {
        return counter;
    }
}

2.2 调用ReentrantLock类

2.2.1 介绍

ReentrantLock类是在java.util.concurrent.locks包下,实现了Lock, Serializable两个接口

JavaGuide提到: ReentrantLock类比Synchronized更灵活,增加了轮询、超时、中断、公平锁和非公平锁等高级功能

ReentrantLock的核心在于内部类Sync,它继承于AQS(AbstractQueuedSynchronizer),分为公平锁和非公平锁两种. 默认是非公平,

和Synchronized一样都是可重入锁(Reentrant意思就是可重入)

连最基本的lock功能都是靠Sync实现,其实ReentrantLock锁就是Sync的一层封装

2.2.2 基本用法:

主要看increment()方法.

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

public class ReentrantLockExample {
    private final Lock lock = new ReentrantLock();
    private int counter = 0;

    // 必须手动释放锁
    public void increment() {
        lock.lock(); // 获取锁
        try {
            counter++;
        } finally {
            lock.unlock(); // 手动释放锁
        }
    }
}

2.2.3 特殊功能

2.2.3.1 等待可中断

很容易实现,用lockInterruptibly()上锁而不是lock().

区别:

lockInterruptibly()在阻塞时运行被其他线程要求中断,结束阻塞

lock()一直阻塞下去,直到获取锁

2.2.3.2 支持超时等待

tryLock(timeout)方法而不是lock()

tryLock()的阻塞超时,则结束阻塞

lock()一直阻塞下去,直到获取锁

2.2.3.3 可以用公平锁

很简单,构造ReentrantLock时传参实现

多个线程阻塞时,锁被释放,线程按先来后到顺序获取锁

2.2.3.4 选择性通知

ReentrantLock实例中可以维护多个Condition,以自定义的条件区分等待队列,相当于有多个监视器锁.而Synchronized只有一个监视器

那公平锁的阻塞线程会进入哪个队列呢?

答案是看它是要获取哪个锁,原生的lock进入原生等待队列,用condition.await()进入该condition的队列

最后总结下悲观锁:

原理是一个线程获取锁,其他线程阻塞

两种具体实现:

1. synchronized关键字

一个线程获取对象/类的监视器锁,其他线程等待锁释放,释放后也不是按申请锁的时间顺序再分配锁的(非公平锁)

2. ReentrantLock类

new一个ReentrantLock对象

要么用lock方法(或其他的高级lock),写业务代码,再用unlock方法手动释放

要么自定义Condition来额外维护线程条件队列,调用await()方法把线程从等待队列转移到condition的条件队列,再用singnal()唤醒

三、乐观锁的实现

3.1 版本号机制

原理: 数据库中加上version字段,更新数据时再次读取version,看是否等于操作前读取的version

3.2 CAS算法

原理:

V：要更新的变量值(Var)
E：预期值(Expected)
N：拟写入的新值(New)

当且仅当 V 的值等于 E 时，CAS 通过原子方式用新值 N 来更新 V 的值。如果不等，说明已经有其它线程更新了 V，则当前线程放弃更新。(来自Java并发常见面试题总结（中） | JavaGuide)

3.3 实现和应用

Java中一般使用版本号+CAS+atomic包实现乐观锁(atomic包同样位于java.util.concurrent下,本意为原子操作,因此不会被其他线程打断)

直接上代码:

import java.util.concurrent.atomic.AtomicInteger;

class OptimisticLockExample {
    private AtomicInteger count = new AtomicInteger(0);
    private AtomicInteger version = new AtomicInteger(0);

    public void increment() {
        int currentCount;
        int currentVersion;
        do {
            // 获取当前的计数值和版本号
            currentCount = count.get();
            currentVersion = version.get();

            // count.compareAndSet(currentCount, currentCount + 1) 比较count的当前值是否等于currentCount
            // 如果相等，则将count的值更新为currentCount + 1，并返回true；否则返回false
            // version.compareAndSet(currentVersion, currentVersion + 1) 同理，对version进行操作
        } while (!count.compareAndSet(currentCount, currentCount + 1) || !version.compareAndSet(currentVersion, currentVersion + 1));
        System.out.println("乐观锁更新后计数: " + count.get() + ", 版本号: " + version.get());
    }
}


public class LockIntroductionExample {
    public static void main(String[] args) {

        OptimisticLockExample optimisticExample = new OptimisticLockExample();

        optimisticExample.increment();
    }
}

以AtomicInteger举例,它有以下方法:

get() 返回当前值

set() 设置为某值

getAndSet() 先返回当前值,再重新赋值

compareAndSet() 与参数值1作比较,相同则赋值为参数2

getAndIncrement() 先返回当前值,再加1

getAndDecrement()等先返回当前值,再减1

除了线程安全,没有什么特别的地方,只是普通的加减

那这些原子操作是怎么实现的呢?

源码中显示:

都是通过sun.misc.Unsafe类实现的,Unsafe类的方法都是native,也就是说通过JNI调用的底层C++代码

我们知道C++代码会进一步编译成汇编,然后直接操作于硬件,当然就可以实现原子性