1.基于Redis的实现方式
（1）Redis有很高的性能；
（2）Redis命令对此支持较好，实现起来比较方便
（3）使用命令介绍：
<1>SETNX:加锁
1.1.setnx(key, val)：
1.1.1.当且仅当key不存在时，set一个key为val的字符串，返回1；
1.1.2.若key存在，则什么都不做，返回0
1.1.3.get(key)：获得key对应的value值，若不存在则返回nil
1.1.4.getset(key, val)：先获取key对应的val值，若不存在则返回nil，然后将旧的val更新为新的val
<2>expire:超时时间
2.1.expire(key, seconds):为key设置一个超时时间,单位为second，超过这个时间锁会自动释放，避免死锁
<3>delete:删除锁
3.1.delete key：删除key
（4）在使用Redis实现分布式锁的时候，主要就会使用到这三个命令
（5）为了确保分布式锁可用，至少要确保锁的实现同时满足以下四个条件
<1>互斥性:在任意时刻，只有一个客户端能持有锁
<2>不会发生死锁:即使有一个客户端在持有锁的期间崩溃而没有主动解锁，也能保证后续其他客户端能加锁
<3>具有容错性:只要大部分的Redis节点正常运行，客户端就可以加锁和解锁。
<2>解铃还须系铃人:加锁和解锁必须是同一个客户端，客户端自己不能把别人加的锁给解了2.Redis单机部署代码实现
（1）首先我们要通过Maven引入Jedis开源组件，在pom.xml文件加入下面的代码
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.9.0</version>
</dependency>
（2）加锁代码
public class RedisTool {
private static final String LOCK_SUCCESS = "OK";
private static final String SET_IF_NOT_EXIST = "NX";
private static final String SET_WITH_EXPIRE_TIME = "PX";
/**
* 尝试获取分布式锁
* @param jedis Redis客户端
* @param lockKey 锁
* @param requestId 请求标识
* @param expireTime 超期时间
* @return 是否获取成功
*/
public static boolean tryGetDistributedLock(Jedis jedis, String lockKey, String requestId, int expireTime) {
String result = jedis.set(lockKey, requestId, SET_IF_NOT_EXIST, SET_WITH_EXPIRE_TIME, expireTime);
if (LOCK_SUCCESS.equals(result)) {return true;}return false;}}
<1>加锁就一行代码：jedis.set(String key, String value, String nxxx, String expx, int time)
<2>这个set()方法一共有五个形参:
2.1.第一个为key，我们使用key来当锁，因为key是唯一的
2.2.第二个为value，传的是requestId,通过给value赋值为requestId
2.3.就知道这把锁是哪个请求加的了，在解锁的时候就可以有依据
2.4.requestId可以使用UUID.randomUUID().toString()方法生成
2.5.第三个参数是NX，即当key不存在时，进行set操作；若key已经存在，则不做任何操作；
2.6.第四个为expx，这个参数传的是PX，意思是要给这个key加一个过期的设置，具体时间由第五个参数决定
2.7.第五个为time，与第四个参数相呼应，代表key的过期时间
（3）解锁代码
public class RedisTool {
private static final Long RELEASE_SUCCESS = 1L;
/**
* 释放分布式锁
* @param jedis Redis客户端
* @param lockKey 锁
* @param requestId 请求标识
* @return 是否释放成功
*/
public static boolean releaseDistributedLock(Jedis jedis, String lockKey, String requestId){
String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
Object result = jedis.eval（script, Collections.singletonList(lockKey), Collections.singletonList(requestId));
if (RELEASE_SUCCESS.equals(result)) {return true;}return false;}}
<1>解锁只需要两行代码就搞定了
1.1.第一行代码，写了一个简单的Lua脚本代码
1.2.第二行代码，将Lua代码传到jedis.eval（)方法里，并使参数KEYS[1]赋值为lockKey，ARGV[1]赋值为requestId
1.3.eval（)方法是将Lua代码交给Redis服务端执行
<2>Lua代码的功能是:
2.1.首先获取锁对应的value值，检查是否与requestId相等,如果相等则删除锁（解锁）
2.2.Lua语言要确保上述操作是原子性的
2.3.就是在eval命令执行Lua代码的时候，Lua代码将被当成一个命令去执行
2.4.并且直到eval命令执行完成，Redis才会执行其他命令3.Redis分布式部署代码实现–分布式锁之redisson
（1）redisson是redis官网推荐的java语言实现分布式锁的项目
（2）redisson远不止分布式锁，还包括其他一些分布式结构
<1>详情请移步：https://github.com/mrniko/redisson/wiki
（3）redisson支持4种链接redis的方式：
<1>Cluster(集群)
<2>Sentinel servers(哨兵)
<3>Master/Slave servers(主从)
<4>Single server(单机)
（4）通过简单的案例使用redisson的lock
<1>RedissonManager类，管理redisson的初始化等操作
public class RedissonManager {
private static final String RAtomicName = "genId_";
private static Config config = new Config();
private static Redisson redisson = null;
public static void init(){
try {config.useClusterServers() //这是用的集群server
.setScanInterval(2000) //设置集群状态扫描时间
.setMasterConnectionPoolSize(10000) //设置连接数
.setSlaveConnectionPoolSize(10000)
.addNodeAddress("127.0.0.1:6379","127.0.0.1:6380");
redisson = Redisson.create(config);
//清空自增的ID数字
RAtomicLong atomicLong = redisson.getAtomicLong(RAtomicName);
atomicLong.set(1);}catch (Exception e){
e.printStackTrace();}}
public static Redisson getRedisson(){return redisson;}
/** 获取redis中的原子ID */
public static Long nextID(){
RAtomicLong atomicLong = getRedisson().getAtomicLong(RAtomicName);
atomicLong.incrementAndGet();
return atomicLong.get();}}
<2>DistributedRedisLock类，提供加锁和解锁方法
public class DistributedRedisLock {
private static Redisson redisson = RedissonManager.getRedisson();
private static final String LOCK_TITLE = "redisLock_";
public static void acquire(String lockName){
String key = LOCK_TITLE + lockName;
RLock mylock = redisson.getLock(key);
//lock提供带timeout参数，timeout结束强制解锁，防止死锁
mylock.lock(2, TimeUnit.MINUTES); System.err.println("======lock======"+Thread.currentThread().getName());}
public static void release(String lockName){
String key = LOCK_TITLE + lockName;
RLock mylock = redisson.getLock(key);
mylock.unlock(); System.err.println("======unlock======"+Thread.currentThread().getName());}}
<3>测试
private static void redisLock(){
RedissonManager.init(); //初始化
for (int i = 0; i < 100; i++) {
Thread t = new Thread(new Runnable() {
@Override
public void run() {try {
String key = "test123";
DistributedRedisLock.acquire(key);
//获得锁之后可以进行相应的处理
Thread.sleep(1000);
System.err.println("======获得锁后进行相应的操作======");
DistributedRedisLock.release(key);
System.err.println("=============================");
} catch (Exception e) {e.printStackTrace();}}});t.start();}}
<4>注意事项：
4.1.在初始化数据时候，最好不要使用static{} 即静态块
4.2.因为在多核机器的情况下读取配置文件
--会抛出java.lang.NoClassDefFoundError: Could not initialize class XXX
4.3.最好还是使用init的方式，在启动程序的时候手动执行下
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
