怎么用java使用redlock

这篇文章将为大家详细讲解有关怎么用java使用redlock，文章内容质量较高，因此小编分享给大家做个参考，希望大家阅读完这篇文章后对相关知识有一定的了解。

一、在pom文件引入redis和redisson依赖：

                                        org.springframework.boot                        spring-boot-starter-data-redis                                                                        org.redisson                        redisson                        3.3.2                

AquiredLockWorker接口类，，主要是用于获取锁后需要处理的逻辑：

/** * Created by fangzhipeng on 2017/4/5. * 获取锁后需要处理的逻辑 */public interface AquiredLockWorker {     T invokeAfterLockAquire() throws Exception;}

二、DistributedLocker 获取锁管理类：

/** * Created by fangzhipeng on 2017/4/5. * 获取锁管理类 */public interface DistributedLocker {     /**      * 获取锁      * @param resourceName  锁的名称      * @param worker 获取锁后的处理类      * @param       * @return 处理完具体的业务逻辑要返回的数据      * @throws UnableToAquireLockException      * @throws Exception      */      T lock(String resourceName, AquiredLockWorker worker) throws UnableToAquireLockException, Exception;      T lock(String resourceName, AquiredLockWorker worker, int lockTime) throws UnableToAquireLockException, Exception;}

nableToAquireLockException ，不能获取锁的异常类：

/** * Created by fangzhipeng on 2017/4/5. * 异常类 */public class UnableToAquireLockException extends RuntimeException {    public UnableToAquireLockException() {    }    public UnableToAquireLockException(String message) {        super(message);    }    public UnableToAquireLockException(String message, Throwable cause) {        super(message, cause);    }}

三、RedissonConnector 连接类：

/** * Created by fangzhipeng on 2017/4/5. * 获取RedissonClient连接类 */@Componentpublic class RedissonConnector {    RedissonClient redisson;    @PostConstruct    public void init(){        redisson = Redisson.create();    }    public RedissonClient getClient(){        return redisson;    }}

四、RedisLocker 类，实现了DistributedLocker：

import org.redisson.api.RLock;import org.redisson.api.RedissonClient;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Component;import java.util.concurrent.TimeUnit;/** * Created by fangzhipeng on 2017/4/5. */@Componentpublic class RedisLocker  implements DistributedLocker{    private final static String LOCKER_PREFIX = "lock:";    @Autowired    RedissonConnector redissonConnector;    @Override    public  T lock(String resourceName, AquiredLockWorker worker) throws InterruptedException, UnableToAquireLockException, Exception {        return lock(resourceName, worker, 100);    }    @Override    public  T lock(String resourceName, AquiredLockWorker worker, int lockTime) throws UnableToAquireLockException, Exception {        RedissonClient redisson= redissonConnector.getClient();        RLock lock = redisson.getLock(LOCKER_PREFIX + resourceName);      // Wait for 100 seconds seconds and automatically unlock it after lockTime seconds        boolean success = lock.tryLock(100, lockTime, TimeUnit.SECONDS);        if (success) {            try {                return worker.invokeAfterLockAquire();            } finally {                lock.unlock();            }        }        throw new UnableToAquireLockException();    }}

五、测试类：

 @Autowired    RedisLocker distributedLocker;    @RequestMapping(value = "/redlock")    public String testRedlock() throws Exception{        CountDownLatch startSignal = new CountDownLatch(1);        CountDownLatch doneSignal = new CountDownLatch(5);        for (int i = 0; i < 5; ++i) { // create and start threads            new Thread(new Worker(startSignal, doneSignal)).start();        }        startSignal.countDown(); // let all threads proceed        doneSignal.await();        System.out.println("All processors done. Shutdown connection");        return "redlock";    }     class Worker implements Runnable {        private final CountDownLatch startSignal;        private final CountDownLatch doneSignal;        Worker(CountDownLatch startSignal, CountDownLatch doneSignal) {            this.startSignal = startSignal;            this.doneSignal = doneSignal;        }        public void run() {            try {                startSignal.await();                distributedLocker.lock("test",new AquiredLockWorker