Java乐观锁原理与实现案例分析

什么是乐观锁？

乐观锁是一种轻量级锁，它假定不会有其它线程修改共享资源，因此，不需要加锁，只要在最后提交时检查是否有其它线程修改了此数据就好了。

如何实现乐观锁？

实现乐观锁的关键是要保证数据提交时的原子性，通常有两种方式来实现：

1. 基于版本号的乐观锁：通过给数据增加一个版本号，每次操作都需要比较版本号是否一致，只有版本号一致才允许进行操作，并更新版本号。如果版本号不一致，则说明其它线程已经修改了该数据，需要进行相应处理。
2. 基于时间戳的乐观锁：通过记录数据保存时间，每次更新时需要比较保存时间是否一致，只有一致才允许更新，并更新保存时间。如果保存时间不一致，则说明其它线程已经修改了该数据，需要进行相应处理。

示例说明

下面分别通过基于版本号的乐观锁和基于时间戳的乐观锁来进行示例说明。

基于版本号的乐观锁示例

// 定义一个数字类
public class Number {
    private int value;
    private int version;

    public Number(int value, int version) {
        this.value = value;
        this.version = version;
    }

    public int getValue() {
        return value;
    }

    public int getVersion() {
        return version;
    }

    public void setValue(int value) {
        this.value = value;
    }

    public void setVersion(int version) {
        this.version = version;
    }
}

// 对数字类进行操作的线程
public class NumberThread extends Thread {
    private Number number;

    public NumberThread(Number number) {
        this.number = number;
    }

    public void run() {
        int value = number.getValue();
        int version = number.getVersion();
        System.out.println("当前值为：" + value + ", 版本号为：" + version);
        // 模拟对数据的操作
        value = value + 1;
        // 更新数据，并更新版本号
        number.setValue(value);
        number.setVersion(version + 1);
        System.out.println("操作后的值为：" + number.getValue() + ", 版本号为：" + number.getVersion());
    }
}

// 测试类
public class TestOptimisticLock {
    public static void main(String[] args) {
        Number number = new Number(10, 1);
        new NumberThread(number).start();
        new NumberThread(number).start();
        new NumberThread(number).start();
    }
}

运行TestOptimisticLock，输出如下：

当前值为：10, 版本号为：1
当前值为：10, 版本号为：1
当前值为：10, 版本号为：1
操作后的值为：11, 版本号为：2
操作后的值为：12, 版本号为：2
操作后的值为：13, 版本号为：2

从运行结果中可以看出，每次操作都会增加版本号，并通过比较版本号的方式来进行乐观锁。

基于时间戳的乐观锁示例

// 定义一个数字类
public class Number {
    private int value;
    private long timestamp;

    public Number(int value, long timestamp) {
        this.value = value;
        this.timestamp = timestamp;
    }

    public int getValue() {
        return value;
    }

    public long getTimestamp() {
        return timestamp;
    }

    public void setValue(int value) {
        this.value = value;
    }

    public void setTimestamp(long timestamp) {
        this.timestamp = timestamp;
    }
}

// 对数字类进行操作的线程
public class NumberThread extends Thread {
    private Number number;

    public NumberThread(Number number) {
        this.number = number;
    }

    public void run() {
        int value = number.getValue();
        long timestamp = number.getTimestamp();
        System.out.println("当前值为：" + value + ", 保存时间为：" + timestamp);
        // 模拟对数据的操作
        value = value + 1;
        // 更新数据，并更新保存时间
        number.setValue(value);
        number.setTimestamp(System.currentTimeMillis());
        System.out.println("操作后的值为：" + number.getValue() + ", 保存时间为：" + number.getTimestamp());
    }
}

// 测试类
public class TestOptimisticLock {
    public static void main(String[] args) {
        Number number = new Number(10, System.currentTimeMillis());
        new NumberThread(number).start();
        new NumberThread(number).start();
        new NumberThread(number).start();
    }
}

运行TestOptimisticLock，输出如下：

当前值为：10, 保存时间为：1632172302459
当前值为：10, 保存时间为：1632172302459
当前值为：10, 保存时间为：1632172302459
操作后的值为：11, 保存时间为：1632172302562
操作后的值为：12, 保存时间为：1632172302568
操作后的值为：13, 保存时间为：1632172302573

从运行结果中可以看出，每次操作都会增加保存时间，并通过比较保存时间的方式来进行乐观锁。