使用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) {

　　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");

　　}

　　}

　　}

 

来源：BridgeLi's Blog