分布式锁简单介绍

超、凢脫俗 2022-07-26 12:24 192阅读 0赞

什么是分布式锁？  
百度百科给出如下定义：  
分布式锁是控制分布式系统之间同步访问共享资源的一种方式。在分布式系统中，常常需要协调他们的动作。如果不同的系统或是同一个系统的不同主机之间共享了一个或一组资源，那么访问这些资源的时候，往往需要互斥来防止彼此干扰来保证一致性，在这种情况下，便需要使用到分布式锁。

如下为简单实现  
接口定义：

public interface DistributedLock extends RemoteObject { 
        long lock() throws RemoteException, TimeoutException;
        long tryLock(long time, TimeUnit unit) throws RemoteException, TimeoutException;
        void unlock(long token) throws RemoteException;
    }

接口实现

public class DistributedLockImpl extends UnicastRemoteObject implements DistributedLock { 
        /** * 超时单位 */
        private TimeUnit lockTimeoutUnit = TimeUnit.SECONDS;
        /** * 锁的令牌 */
        private volatile long token = 0;
        /** * 同步对象 */
        byte[] lock = new byte[0];
        /** * 默认永不超时 */
        long lockTimeout = 60 * 60;//默认超时3600秒
        long beginLockTime;//获取令牌时间，单位毫秒
    
    
        public DistributedLockImpl() throws RemoteException {
            super();
        }
    
    
        /** * @param lockTimeout 锁超时时间，如果加锁的对象不解锁，超时之后自动解锁 * @param lockTimeoutUnit * @throws RemoteException */
        public DistributedLockImpl(long lockTimeout, TimeUnit lockTimeoutUnit) throws RemoteException {
            super();
            this.lockTimeout = lockTimeout;
            this.lockTimeoutUnit = this.lockTimeoutUnit;
        }
        public long lock() throws TimeoutException {
            return tryLock(0, TimeUnit.MILLISECONDS);
        }
        private boolean isLockTimeout() {
            if (lockTimeout <= 0) {
                return false;
            }
            return (System.currentTimeMillis() - beginLockTime) < lockTimeoutUnit.toMillis(lockTimeout);
        }
        private long getToken() {
            beginLockTime = System.currentTimeMillis();
            token = System.nanoTime();
            return token;
        }
        public long tryLock(long time, TimeUnit unit) throws TimeoutException {
            synchronized (lock) {
                long startTime = System.nanoTime();
                while (token != 0 && isLockTimeout()) {
                    try {
                        if (time > 0) {
                            long endTime = System.nanoTime();
                            if (endTime - startTime >= unit.toMillis(time)) {
                                throw new TimeoutException();
                            }
                        }
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        //DO Noting
                    }
                }
                return getToken();
            }
        }
        public void unlock(long token) {
            if (this.token != 0 && token == this.token) {
                this.token = 0;
            } else {
                throw new RuntimeException("令牌" + token + "无效.");
            }
        }
    }

上面的代码提供了，永远等待的获取锁的lock方法和如果在指定的时间获取锁失败就获得超时异常的tryLock方法，另外还有一个unlock方法。

技术的关键点实际上就是在token上，上面的实现，有一个基本的假设，就是两次远程调用之间的时间不可能在1纳秒之内完成。因此，每次锁的操作都会返回一个长整型的令牌，就是当时执行时间的纳秒数。下次解锁必须用获得的令牌进行解锁，才可以成功。如此，解锁就不用添加同步操作了，从而解决掉lock和unlock都加了synchronize关键字死锁的问题。

实际上，没有令牌也是可以的，但是那样就会导致a获取了锁，但是b执行unlock也会成功解锁，是不安全的，而加入令牌，就可以保证只有加锁者才可以解锁。

测试代码如下：

public class TestDLock { 
        public static void main(String[] args) throws Exception {
            RmiServer rmiServer = new LocalRmiServer();
            DistributedLockImpl distributedLock = new DistributedLockImpl();
            rmiServer.registerRemoteObject("lock1", distributedLock);
            MultiThreadProcessor processor = new MultiThreadProcessor("aa");
            for (int i = 0; i < 8; i++) {
                processor.addProcessor(new RunLock("aa" + i));
            }
            long s = System.currentTimeMillis();
            processor.start();
            long e = System.currentTimeMillis();
            System.out.println(e - s);
            rmiServer.unexportObject(distributedLock);
        }
    }
    
    class RunLock extends AbstractProcessor { 
        public RunLock(String name) {
            super(name);
        }
    
        @Override
        protected void action() throws Exception {
            try {
                RmiServer client = new RemoteRmiServer();
                DistributedLock lock = client.getRemoteObject("lock1");
                for (int i = 0; i < 1000; i++) {
                    long token = lock.lock();
                    lock.unlock(token);
                }
                System.out.println("end-" + Thread.currentThread().getId());
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
    }

执行结果如下：

-0    [main] INFO   - 线程组<aa>运行开始,线程数8...
    -3    [aa-aa0] INFO   - 线程<aa-aa0>运行开始...
    -3    [aa-aa1] INFO   - 线程<aa-aa1>运行开始...
    -3    [aa-aa2] INFO   - 线程<aa-aa2>运行开始...
    -3    [aa-aa3] INFO   - 线程<aa-aa3>运行开始...
    -3    [aa-aa4] INFO   - 线程<aa-aa4>运行开始...
    -4    [aa-aa5] INFO   - 线程<aa-aa5>运行开始...
    -4    [aa-aa6] INFO   - 线程<aa-aa6>运行开始...
    -8    [aa-aa7] INFO   - 线程<aa-aa7>运行开始...
    end-19
    -9050 [aa-aa3] INFO   - 线程<aa-aa3>运行结束
    end-17
    -9052 [aa-aa1] INFO   - 线程<aa-aa1>运行结束
    end-20
    -9056 [aa-aa4] INFO   - 线程<aa-aa4>运行结束
    end-16
    -9058 [aa-aa0] INFO   - 线程<aa-aa0>运行结束
    end-21
    -9059 [aa-aa5] INFO   - 线程<aa-aa5>运行结束
    end-26
    -9063 [aa-aa7] INFO   - 线程<aa-aa7>运行结束
    end-18
    -9064 [aa-aa2] INFO   - 线程<aa-aa2>运行结束
    end-22
    -9065 [aa-aa6] INFO   - 线程<aa-aa6>运行结束
    -9066 [main] INFO   - 线程组<aa>运行结束, 用时:9065ms
    9069

也就是9069ms中执行了8000次锁定及解锁操作。

小结：

上面的分布式锁实现方案，综合考虑了实现简单，锁安全，锁超时等因素。实际测试，大概900到1000次获取锁和释放锁操作每秒，可以满足大多数应用要求。

参考博文：[http://my.oschina.net/tinyframework/blog/192778][http_my.oschina.net_tinyframework_blog_192778]

[http_my.oschina.net_tinyframework_blog_192778]: http://my.oschina.net/tinyframework/blog/192778