Lock的使用

一、一些常用方法的封装

public class Lock {
    private static LockProvider provider;

    /**
     * 尝试获取一个锁
     *
     * @param name 锁标识
     * @return 是否锁定
     */
    public static boolean lock(String name) {
        return lock(name, 1L, TimeUnit.MINUTES);
    }

    /**
     * 尝试获取一个锁
     *
     * @param name      锁标识
     * @param leaseTime 锁定时间
     * @param timeUnit  时间单位
     * @return 是否锁定
     */
    public static boolean lock(String name, long leaseTime, TimeUnit timeUnit) {
        return lock(name, 0L, leaseTime, timeUnit);
    }

    /**
     * 尝试获取一个锁
     *
     * @param name      锁标识
     * @param waitTime  等待时间
     * @param leaseTime 锁定时间
     * @param timeUnit  时间单位
     * @return 是否锁定
     */
    public static boolean lock(String name, long waitTime, long leaseTime, TimeUnit timeUnit) {
        return provider.lock(name, waitTime, leaseTime, timeUnit);
    }

    /**
     * @param name 锁标识
     * @return 是否已经被锁
     */
    public static boolean isLocked(String name) {
        return provider.isLocked(name);
    }

    /**
     * @param name 锁标识
     */
    public static void unlock(String name) {
        provider.unlock(name);
    }
}

public interface LockProvider {
    boolean lock(String name, long waitTime, long leaseTime, TimeUnit timeUnit);

    boolean isLocked(String name);

    void unlock(String name);
}

public class MemoryLockProvider implements LockProvider {
    private final Map<String, ReentrantLock> locks = new ConcurrentHashMap();

    public MemoryLockProvider() {
    }

    public boolean lock(String name, long waitTime, long leaseTime, TimeUnit timeUnit) {
        ReentrantLock lock = (ReentrantLock)this.locks.computeIfAbsent(name, (cacheName) -> {
            return new ReentrantLock();
        });

        try {
            if (waitTime > 0L) {
                Thread.sleep(timeUnit.toMillis(waitTime));
            }

            return lock.tryLock(leaseTime, timeUnit);
        } catch (InterruptedException var9) {
            var9.printStackTrace();
            return false;
        }
    }

    public boolean isLocked(String name) {
        ReentrantLock lock = (ReentrantLock)this.locks.get(name);
        return lock == null ? false : lock.isLocked();
    }

    public void unlock(String name) {
        ReentrantLock lock = (ReentrantLock)this.locks.get(name);
        if (lock != null) {
            lock.unlock();
            this.locks.remove(name);
        }
    }
}

public class RedisLockProvider implements LockProvider {
    private final RedissonClient redissonClient;

    public RedisLockProvider(RedissonClient redissonClient) {
        this.redissonClient = redissonClient;
        this.init();
    }

    public boolean lock(String name, long waitTime, long leaseTime, TimeUnit timeUnit) {
        RLock lock = this.redissonClient.getLock(name);

        try {
            return lock.tryLock(waitTime, leaseTime, timeUnit);
        } catch (InterruptedException var9) {
            var9.printStackTrace();
            return false;
        }
    }

    public boolean isLocked(String name) {
        RLock lock = this.redissonClient.getLock(name);
        return lock.isLocked();
    }

    public void unlock(String name) {
        RLock lock = this.redissonClient.getLock(name);
        lock.unlock();
    }

    private void init() {
        try {
            Field clientField = Lock.class.getDeclaredField("provider");
            clientField.setAccessible(true);
            clientField.set((Object)null, this);
        } catch (IllegalAccessException | NoSuchFieldException var3) {
            throw new IllegalStateException("init redis lock provider failure", var3);
        }
    }
}