Redis分布式锁及缓存的简单实现

1. 分布式锁

1. 加锁（保证原子操作）
- set key value nx ex seconds

2. 解锁
- del key

• 代码实现

package com.bytedance.lms.redis;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.params.SetParams;

import java.util.Arrays;
import java.util.List;
import java.util.Random;
import java.util.UUID;

/**
 * 实现分布式锁
 */
public class DistributedLockTest {

    // key 分布式锁，
    private String key, value;

    // 释放锁的luna脚本，也就是get key, del key的原子操作
    // 要求传入key和对应的args（数组形式），目的就是校验当前的这个value是否是当前的这个服务器生成的，如果不是
    // 那么当前的服务器无法进行释放该锁🔒
    private String script = "if redis.call('get',KEYS[1]) == ARGV[1] then return redis.call('del',KEYS[1]) else return 0 end";

    public DistributedLockTest(String lockName) {
        this.key = lockName;
    }

    // 创建redis链接
    public static JedisPool initRedis() {
        //Jedis连接池
        JedisPoolConfig config = new JedisPoolConfig();
        // 最大空闲连接数
        config.setMaxIdle(8);
        // 最大连接数
        config.setMaxTotal(8);
        // 获取连接的最大等待时间，如果超时就抛出异常
        config.setMaxWaitMillis(1000);
        //参数分别为Jedis连接池实例、redis服务器地址、redis端口号、超时时间、密码（默认为空）、数据库索引（从0开始）
        JedisPool jedisPool = new JedisPool(config, "127.0.0.1", 6379, 10000, null, 0);
        return jedisPool;
    }


    /**
     * 加锁,设置锁的超时时间
     */
    public void lock(long expiredTime) {
        try (Jedis jedis = initRedis().getResource()) {
            while (true) {
                value = UUID.randomUUID().toString().trim().replaceAll("-", "");
                // 设置分布式锁，nx表示存在就设置失败，否则成功以及超时时间(原子操作)
                String result = jedis.set(key, value, SetParams.setParams().nx().px(expiredTime));
                // ok代表锁添加成功
                if ("OK".equals(result)) {
                    break;
                }
                // 加锁失败，等待1s后重试
                Thread.sleep(1000);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 释放分布式锁，使用的是luna脚本进行，保证原子性操作
     */
    public void unlock() {
        try (Jedis jedis = initRedis().getResource()) {
            List<String> keys = Arrays.asList(new String[]{key});
            List<String> values = Arrays.asList(new String[]{value});
            // 释放锁
            jedis.eval(script, keys, values);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    DistributedLockTest lock = new DistributedLockTest("lock:vote");
                    System.out.println("尝试加锁......");
                    // 加锁失败会一直阻塞在这里，无法向下执行
                    lock.lock(1000 * 5);
                    System.out.println("加锁成功......");
                    try {
                        System.out.println("修改票数: " + Thread.currentThread().getName());
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally {
                        // 释放锁
                        lock.unlock();
                        System.out.println("解锁成功");
                    }
                }
            }).start();
        }
    }
}

• 结果