BridgeLi's Blog

大家都知道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