Redis实现分布式锁

大家都知道Redis是NoSQL的一种，目前在互联网公司中在作为缓存广泛的使用者，其实利用Redis的setnx还可以快速实现一个分布式锁，公司的业务就需要使用分布式锁保证数据的唯一性，经检索在网上发现已经有活雷锋分享了一套，本着不在重新发明轮子的想法，测试了一下好像没有问题，几乎不用对原代码进行修改，就能使用，下面就分享在这里，供需要的朋友参考。原文里面还有对实现的原理进行解释，所以本文就不再赘述，详情请通过参考资料进行访问。

package cn.bridgeli.distributedlock;

import java.util.UUID;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.Transaction;

public class RedisDistributedLock {

  private static final Logger LOG = LoggerFactory.getLogger(RedisDistributedLock.class);

  private static final String redisHost = "127.0.0.1";

  private static final int port = 6381;

  private static JedisPoolConfig config;

  private static JedisPool pool;

  private static ExecutorService service;

  private static int ThLeng = 10;

  private static CountDownLatch latch;

  private static AtomicInteger Countor = new AtomicInteger(0);

  private static int count = 0;

  private static String LockName = "mylock_test10";

  static {
    // 利用Redis连接池，保证多个线程利用多个连接，充分模拟并发性
    config = new JedisPoolConfig();
    config.setMaxIdle(10);
    config.setMaxWaitMillis(1000);
    config.setMaxTotal(30);
    pool = new JedisPool(config, redisHost, port);
    // 利用ExecutorService 管理线程
    service = Executors.newFixedThreadPool(ThLeng);
    // CountDownLatch保证主线程在全部线程结束之后退出
    latch = new CountDownLatch(ThLeng);
  }

  /**
   * 获取锁 tips：生成一个UUID，作为Key的标识，不断轮询lockName，直到set成功，表示成功获取锁。
   * 其他的线程在set此lockName时被阻塞直到超时。
   *
   * @param pool
   * @param lockName
   * @param timeouts
   * @return 锁标志
   */
  public static String getLock(JedisPool pool, String lockName, long timeouts) {
    Jedis client = pool.getResource();
    try {
      String value = UUID.randomUUID().toString();
      long timeWait = System.currentTimeMillis() + timeouts * 1000;
      while (System.currentTimeMillis() < timeWait) {
        if (client.setnx(lockName, value) == 1) {
          // 防止key卡死，一直不释放锁，所以1800s过期
          client.expire(lockName, 1800);
          LOG.info("lock geted");
          return value;
        }
        try {
          Thread.sleep(1000);
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
        LOG.info("get lock timeouts");
      } finally {
        // pool.returnBrokenResource(client);
        pool.returnResource(client);
      }
    }
    return null;
  }

  /**
   * 释放锁 tips：对lockName做watch，开启一个事务，删除以LockName为key的锁，删除后，此锁对于其他线程为可争抢的。
   *
   * @param pool
   * @param lockName
   * @param value
   */
  public static void relaseLock(JedisPool pool, String lockName, String value) {
    Jedis client = pool.getResource();
    try {
      while (true) {
        client.watch(lockName);
        if (client.get(lockName).equals(value)) {
          Transaction tx = client.multi();
          tx.del(lockName);
          tx.exec();
          return;
        }
        client.unwatch();
      } finally {
        // pool.returnBrokenResource(client);
        pool.returnResource(client);
      }
    }
  }

  public static void main(String args[]) {
    for (int i = 0; i < ThLeng; i++) {
      String tName = "thread-" + i;
      Thread t = new Thread(new SubAddThread(pool, tName));
      LOG.info(tName + "inited...");
      service.submit(t);
    }
    service.shutdown();
    try {
      latch.await();
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    LOG.info(Countor.get() + "");
    LOG.info(count + "");
  }
}

public static class SubAddThread implements Runnable {

  private String name;

  private JedisPool pool;

  public SubAddThread(JedisPool pool, String uname) {
    this.pool = pool;
    this.name = uname;
  }

  @Override
  public void run() {
    for (int i = 0; i < 100; i++) {
      LOG.info(name + " starting...");
      String valuse = getLock(pool, LockName, 50);
      LOG.info(name + " get Lock " + valuse);
      count++;
      relaseLock(pool, LockName, valuse);
      Countor.incrementAndGet();
      LOG.info(name + " " + count);
    }
    latch.countDown();
    LOG.info(name + " complated");
  }
}

参考资料：http://www.jianshu.com/p/c1f5d26cb1c9