两种分布式锁实现方案(二)

四。方案2,基于redis的分布式锁

/** * 分布式锁工厂类 */public class RedisLockUtil {    private static final Logger logger = Logger.getLogger(RedisLockUtil.class);    private static Object schemeLock = new Object();    private static Map<String, RedisLockUtil> instances = new ConcurrentHashMap();    public static RedisLockUtil getInstance(String schema) {        RedisLockUtil u = instances.get(schema);        if (u == null) {            synchronized (schemeLock) {                u = instances.get(schema);                if (u == null) {                    LockObserver lo = new LockObserver(schema);                    u = new RedisLockUtil(schema, lo);                    instances.put(schema, u);                }            }        }        return u;    }    private Object mutexLock = new Object();    private Map<String, Object> mutexLockMap = new ConcurrentHashMap();    private Map<String, RedisReentrantLock> cache = new ConcurrentHashMap<String, RedisReentrantLock>();    private DelayQueue<RedisReentrantLock> dq = new DelayQueue<RedisReentrantLock>();    private AbstractLockObserver lo;    public RedisLockUtil(String schema, AbstractLockObserver lo) {        Thread th = new Thread(lo);        th.setDaemon(false);        th.setName("Lock Observer:"schema);        th.start();        clearUselessLocks(schema);        this.lo = lo;    }    public void clearUselessLocks(String schema) {        Thread th = new Thread(new Runnable() {            @Override            public void run() {                while (!SystemExitListener.isOver()) {                    try {                        RedisReentrantLock t = dq.take();                        if (t.clear()) {                            String key = t.getKey();                            synchronized (getMutex(key)) {                                cache.remove(key);                            }                        }                        t.resetCleartime();                    } catch (InterruptedException e) {                    }                }            }        });        th.setDaemon(true);        th.setName("Lock cleaner:"schema);        th.start();    }    private Object getMutex(String key) {        Object mx = mutexLockMap.get(key);        if (mx == null) {            synchronized (mutexLock) {                mx = mutexLockMap.get(key);                if (mx == null) {                    mx = new Object();                    mutexLockMap.put(key, mx);                }            }        }        return mx;    }    private RedisReentrantLock getLock(String key, boolean addref) {        RedisReentrantLock lock = cache.get(key);        if (lock == null) {            synchronized (getMutex(key)) {                lock = cache.get(key);                if (lock == null) {                    lock = new RedisReentrantLock(key, lo);                    cache.put(key, lock);                }            }        }        if (addref) {            if (!lock.incRef()) {                synchronized (getMutex(key)) {                    lock = cache.get(key);                    if (!lock.incRef()) {                        lock = new RedisReentrantLock(key, lo);                        cache.put(key, lock);                    }                }            }        }        return lock;    }    public void reset() {        for (String s : cache.keySet()) {            getLock(s, false).unlock();        }    }    /**     * 尝试加锁     * 如果当前线程已经拥有该锁的话,直接返回,表示不用再次加锁,此时不应该再调用unlock进行解锁     *     * @param key     * @return     * @throws Exception     * @throws InterruptedException     * @throws KeeperException     */    public LockStat lock(String key) {        return lock(key, -1);    }    public LockStat lock(String key, int timeout) {        RedisReentrantLock ll = getLock(key, true);        ll.incRef();        try {            if (ll.isOwner(false)) {                ll.descrRef();                return LockStat.NONEED;            }            if (ll.lock(timeout)) {                return LockStat.SUCCESS;            } else {                ll.descrRef();                if (ll.setCleartime()) {                    dq.put(ll);                }                return null;            }        } catch (LockNotExistsException e) {            ll.descrRef();            return lock(key, timeout);        } catch (RuntimeException e) {            ll.descrRef();            throw e;        }    }    public void unlock(String key, LockStat stat) {        unlock(key, stat, false);    }    public void unlock(String key, LockStat stat, boolean keepalive) {        if (stat == null) return;        if (LockStat.SUCCESS.equals(stat)) {            RedisReentrantLock lock = getLock(key, false);            boolean candestroy = lock.unlock();            if (candestroy && !keepalive) {                if (lock.setCleartime()) {                    dq.put(lock);                }            }        }    }    public static enum LockStat {        NONEED,        SUCCESS    }}

/** * 分布式锁本地代理类 */public class RedisReentrantLock implements Delayed {    private static final Logger logger = Logger.getLogger(RedisReentrantLock.class);    private ReentrantLock reentrantLock = new ReentrantLock();    private RedisLock redisLock;    private long timeout = 3 * 60;    private CountDownLatch lockcount = new CountDownLatch(1);    private String key;    private AbstractLockObserver observer;    private int ref = 0;    private Object refLock = new Object();    private boolean destroyed = false;    private long cleartime = -1;    public RedisReentrantLock(String key, AbstractLockObserver observer) {        this.key = key;        this.observer = observer;        initWriteLock();    }    public boolean isDestroyed() {        return destroyed;    }    private synchronized void initWriteLock() {        redisLock = new RedisLock(key, new LockListener() {            @Override            public void lockAcquired() {                lockcount.countDown();            }            @Override            public long getExpire() {                return 0;            }            @Override            public void lockError() {                /*synchronized(mutex){mutex.notify();}*/                lockcount.countDown();            }        }, observer);    }    public boolean incRef() {        synchronized (refLock) {            if (destroyed) return false;            ref;        }        return true;    }    public void descrRef() {        synchronized (refLock) {            ref--;        }    }    public boolean clear() {        if (destroyed) return true;        synchronized (refLock) {            if (ref > 0) {                return false;            }            destroyed = true;            redisLock.clear();            redisLock = null;            return true;        }    }    public boolean lock(long timeout) throws LockNotExistsException {        if (timeout <= 0) timeout = this.timeout;        //incRef();        reentrantLock.lock();//多线程竞争时，先拿到第一层锁        if (redisLock == null) {            reentrantLock.unlock();            //descrRef();            throw new LockNotExistsException();        }        try {            lockcount = new CountDownLatch(1);            boolean res = redisLock.trylock(timeout);            if (!res) {                lockcount.await(timeout, TimeUnit.SECONDS);                //mutex.wait(timeout*1000);                if (!redisLock.doExpire()) {                    reentrantLock.unlock();                    return false;                }            }            return true;        } catch (InterruptedException e) {            reentrantLock.unlock();            return false;        }    }    public boolean lock() throws LockNotExistsException {        return lock(timeout);    }    public boolean unlock() {        if (!isOwner(true)) {            try {                throw new RuntimeException("big ================================================ error.key:"key);            } catch (Exception e) {                logger.error("err:"e, e);            }            return false;        }        try {            redisLock.unlock();            reentrantLock.unlock();//多线程竞争时，释放最外层锁        } catch (RuntimeException e) {            reentrantLock.unlock();//多线程竞争时，释放最外层锁            throw e;        } finally {            descrRef();        }        return canDestroy();    }    public boolean canDestroy() {        synchronized (refLock) {            return ref <= 0;        }    }    <a href="http://www.nbso.ca/">    nbso online    casino reviews    </a>    public String getKey() {        return key;    }    public void setKey(String key) {        this.key = key;    }    public boolean isOwner(boolean check) {        synchronized (refLock) {            if (redisLock == null) {                logger.error("reidsLock is null:key="key);                return false;            }            boolean a = reentrantLock.isHeldByCurrentThread();            boolean b = redisLock.isOwner();            if (check) {                if (!a || !b) {                    logger.error(key";a:"a";b:"b);                }            }            return a && b;        }    }    public boolean setCleartime() {        synchronized (this) {            if (cleartime > 0) return false;            this.cleartime = System.currentTimeMillis() 10 * 1000;            return true;        }    }    public void resetCleartime() {        synchronized (this) {            this.cleartime = -1;        }    }    @Override    public int compareTo(Delayed object) {        if (object instanceof RedisReentrantLock) {            RedisReentrantLock t = (RedisReentrantLock) object;            long l = this.cleartime - t.cleartime;            if (l > 0) return 1; //比当前的小则返回1，比当前的大则返回-1，否则为0            else if (l < 0) return -1;            else return 0;        }        return 0;    }    @Override    public long getDelay(TimeUnit unit) {        long d = unit.convert(cleartime - System.currentTimeMillis(), TimeUnit.MILLISECONDS);        return d;    }}

/** * 使用Redis实现的分布式锁 * 基本工作原理如下： * 1. 使用setnx(key,时间戮 超时)，如果设置成功，则直接拿到锁 * 2. 如果设置不成功，获取key的值v1（它的到期时间戮）,跟当前时间对比，看是否已经超时 * 3. 如果超时（说明拿到锁的结点已经挂掉)，v2=getset(key,时间戮 超时 1)，判断v2是否等于v1，如果相等，加锁成功，否则加锁失败，等过段时间再重试(200MS) */public class RedisLock implements LockListener {    private String key;    private boolean owner = false;    private AbstractLockObserver observer = null;    private LockListener lockListener = null;    private boolean waiting = false;    private long expire;//锁超时时间，以秒为单位    private boolean expired = false;    public RedisLock(String key, LockListener lockListener, AbstractLockObserver observer) {        this.key = key;        this.lockListener = lockListener;        this.observer = observer;    }    public boolean trylock(long expire) {        synchronized (this) {            if (owner) {                return true;            }            this.expire = expire;            this.expired = false;            if (!waiting) {                owner = observer.tryLock(key, expire);                if (!owner) {                    waiting = true;                    observer.addLockListener(key, this);                }            }            return owner;        }    }    public boolean isOwner() {        return owner;    }    public void unlock() {        synchronized (this) {            observer.unLock(key);            owner = false;        }    }    public void clear() {        synchronized (this) {            if (waiting) {                observer.removeLockListener(key);                waiting = false;            }        }    }    public boolean doExpire() {        synchronized (this) {            if (owner) return true;            if (expired) return false;            expired = true;            clear();        }        return false;    }    @Override    public void lockAcquired() {        synchronized (this) {            if (expired) {                unlock();                return;            }            owner = true;            waiting = false;        }        lockListener.lockAcquired();    }    @Override    public long getExpire() {        return this.expire;    }    @Override    public void lockError() {        synchronized (this) {            owner = false;            waiting = false;            lockListener.lockError();        }    }}

public class LockObserver extends AbstractLockObserver implements Runnable {    private CacheRedisClient client;    private Object mutex = new Object();    private Map<String, LockListener> lockMap = new ConcurrentHashMap();    private boolean stoped = false;    private long interval = 500;    private boolean terminated = false;    private CountDownLatch doneSignal = new CountDownLatch(1);    public LockObserver(String schema) {        client = new CacheRedisClient(schema);        SystemExitListener.addTerminateListener(new ExitHandler() {            public void run() {                stoped = true;                try {                    doneSignal.await();                } catch (InterruptedException e) {                }            }        });    }    public void addLockListener(String key, LockListener listener) {        if (terminated) {            listener.lockError();            return;        }        synchronized (mutex) {            lockMap.put(key, listener);        }    }    public void removeLockListener(String key) {        synchronized (mutex) {            lockMap.remove(key);        }    }    @Override    public void run() {        while (!terminated) {            long p1 = System.currentTimeMillis();            Map<String, LockListener> clone = new HashMap();            synchronized (mutex) {                clone.putAll(lockMap);            }            Set<String> keyset = clone.keySet();            if (keyset.size() > 0) {                ConnectionFactory.setSingleConnectionPerThread(keyset.size());                for (String key : keyset) {                    LockListener ll = clone.get(key);                    try {                        if (tryLock(key, ll.getExpire())) {                            ll.lockAcquired();                            removeLockListener(key);                        }                    } catch (Exception e) {                        ll.lockError();                        removeLockListener(key);                    }                }                ConnectionFactory.releaseThreadConnection();            } else {                if (stoped) {                    terminated = true;                    doneSignal.countDown();                    return;                }            }            try {                long p2 = System.currentTimeMillis();                long cost = p2 - p1;                if (cost <= interval) {                    Thread.sleep(interval - cost);                } else {                    Thread.sleep(interval * 2);                }            } catch (InterruptedException e) {            }        }    }    /**     * 超时时间单位为s!!!     *     * @param key     * @param expire     * @return     */    public boolean tryLock(final String key, final long expireInSecond) {        if (terminated) return false;        final long tt = System.currentTimeMillis();        final long expire = expireInSecond * 1000;        final Long ne = tt expire;        List<Object> mm = client.multi(key, new MultiBlock() {            @Override            public void execute() {                transaction.setnxObject(key, ne);                transaction.get(SafeEncoder.encode(key));            }        });        Long res = (Long) mm.get(0);        if (new Long(1).equals(res)) {            return true;        } else {            byte[] bb = (byte[]) mm.get(1);            Long ex = client.deserialize(bb);            if (ex == null || tt > ex) {                Long old = client.getSet(key, new Long(ne 1));                if (old == null || (ex == null && old == null) || (ex != null && ex.equals(old))) {                    return true;                }            }        }        return false;    }    public void unLock(String key) {        client.del(key);    }}

使用本方案实现的分布式锁，可以完美地解决锁重入问题；通过引入超时也避免了死锁问题；性能方面，笔者自测试结果如下：


500线程 tps = 35000
[root@DB1 benchtest-util]# target/benchtest/bin/TestFastRedis /data/config/util/config_0_11.properties lock 500 500000
线程总时间：6553466；平均:13.106932
实际总时间：13609; 平均：0.027218

TPS达到35000，比方案1强了整整一个数量级；

五。总结
本文介绍了两种分布式锁的实现方案；方案1最大的优势在于避免结点挂掉后导致的死锁；方案2最大的优势在于性能超强；在实际生产过程中，结合自身情况来决定最适合的分布式锁方案是架构师的必修课。