模拟实现Tair中的版本号

模拟实现Tair中的版本号

最近在公司项目中，遇到了一个分布式多线程并发环境下的短信重复发送问题，最后使用的分布式锁解决。在公司的缓存框架 Tair 中有 version 机制，这个 version 可以作为一个分布式锁使用。对 version 机制比较好奇，但是还没来得及去看框架源码，准备先自己在多线程环境下模拟一个类似的 version 机制。

一、需求

Tair是 Key-Value 型数据库，在 Tair 中插入数据时主要有以下几种情况：
1、在 put 的时候，如果传入的 version 为0，则解释为强制覆盖，库中的 version 也会设置为0，且更新 value;
2、当传入的 version 不为0时，又存在两种情况：

• 数据不存在，则直接 put数据，且不管传入的 version 为多少，库中version都设置为1；
• 若数据已经存在，则比较传入的 version 与库中的 version 是否相同，不同则返回 error，相同则覆盖数据，并将库中的 version 设置为 version + 1；

当满足以上需求后，如果我们想实现一个锁机制，则只用在插入数据的时候将其版本号设置成除 0、1 以外的任意数，在并发环境下，只要有一个任务插入成功，则库中 version 则会变成 1，其他的任务都无法插入成功，也就实现了锁的获取。

二、代码实现

public class VersionImpl {

    /**
     * 数据总量
     */
    static final int NUM_DATA = 10;

    /**
     * 处理一条数据的线程数
     */
    static final int NUM_THREAD = 10;

    /**
     * 数据容器，可以看作数据库中的每条表，暂时用下标代替key或者说是id
     */
    static Entity[] dataArray = new Entity[NUM_DATA];

    static class Entity {
        int version;
        String data;
        ReentrantLock lock;
        public Entity(int version, String data) {
            this.version = version;
            this.data = data;
            this.lock = new ReentrantLock();
        }
    }

    static {
        for (int i = 0; i < NUM_DATA; i++) {
            dataArray[i] = new Entity(0, null);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = MyUtils.getExecutorService();
        CountDownLatch countDownLatch = new CountDownLatch(10);
        for (int i = 0; i < NUM_DATA; i++) {
            for (int j = 0; j < NUM_THREAD; j++) {
                VersionTask task = new VersionTask(i, j, i + "task");
                executorService.submit(task);
                countDownLatch.countDown();
            }
        }
        countDownLatch.await();
        executorService.shutdown();
    }

    public static class VersionTask implements Callable<Boolean> {

        private final int id;
        private final int version;
        private final String newData;

        public VersionTask(int id, int version, String newData) {
            this.id = id;
            this.version = version;
            this.newData = newData;
        }

        @Override
        public Boolean call() {
            return putOnVersionEqual0() || putOnDataIsEmpty() || putOnVersionEquals();
        }

        private boolean putOnVersionEqual0() {
            if (this.version == 0) {
                synchronized (dataArray[this.id]) {
                    dataArray[this.id].version = 0;
                    modifyData();
                    return true;
                }
            }
            return false;
        }

        private boolean putOnDataIsEmpty() {
            if (StringUtils.isEmpty(dataArray[this.id].data)) {
                synchronized (dataArray[this.id]) {
                    if (StringUtils.isEmpty(dataArray[this.id].data)) {
                        dataArray[this.id].version = 1;
                        modifyData();
                        return true;
                    }
                }
            }
            return false;
        }

        private boolean putOnVersionEquals() {
            if (dataArray[this.id].version == this.version) {
                synchronized (dataArray[this.id]) {
                    if (dataArray[this.id].version == this.version) {
                        dataArray[this.id].version += 1;
                        modifyData();
                        return true;
                    }
                }
            }
            return false;
        }

        private void modifyData() {
            dataArray[this.id].data = this.newData;
            System.out.println(String.format("run success. id:%d version:%d data_version:%d ", this.id, this.version, dataArray[this.id].version));
        }
    }

}

三、结果输出

1、在上面代码中，有10个不同的数据，每个数据分别有10个线程并发操作，我们传入的 version 为 0~9 的下标，所以按需求，对于 id 相同的数据，只会有有序的输出。



2、如果我们把所有元素的 version 改为1，则第一次插入，不管插入的什么元素，库中 version 都会变成1，这时候，原来version为1的任务能够插入成功，所以这种情况下可能有两条输出。



3、当把 version 改成0，则会强制覆盖，每条记录的10个任务都会输出成功。