《自己动手写框架4》：分布式锁的简单实现

lock方法添加了个long返回值。tryLock方法，返回的也不是boolean。也是long，unlock方法多了一个long參数型參数，呵呵。技巧就在这里了。

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 + "无效.");
        }
    }
}

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();
        }
    }
}