redis redisson 普通锁示例（RLock）

---

redis redisson 普通锁示例

 

 

*********************

相关类及接口

 

RLock

public interface RLock extends Lock, RLockAsync {

    String getName();                     //加锁的key

    void lockInterruptibly(long var1, TimeUnit var3) throws InterruptedException;
    boolean tryLock(long var1, long var3, TimeUnit var5) throws InterruptedException;
    void lock(long var1, TimeUnit var3);  //获取锁对象，设置过期时间到期自动释放，采用此种加锁方式，可能发生任务没有完成锁就释放

    boolean forceUnlock();                //解锁
    boolean isLocked();                   //锁是否被占用

    boolean isHeldByThread(long var1);    //锁是否被指定线程占用
    boolean isHeldByCurrentThread();      //锁是否被当前线程占用

    int getHoldCount();                   //等待获取所的线程数
    long remainTimeToLive();              //所得剩余时间
}

 

Lock

public interface Lock {

    void lock();
    void lockInterruptibly() throws InterruptedException;  //加锁

    boolean tryLock();         //如果不能获得锁，立刻返回
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
                               //如果在指定的时间内不能获得锁，则立刻返回

    void unlock();             //释放锁对象
    Condition newCondition();  //获得与锁相关的condition对象
}

说明：加锁使用此接口的lock()方法，可保证正常情况下业务没有完成锁不会释放

 

RLockAsync：异步锁接口

public interface RLockAsync {

    RFuture<Void> lockAsync();
    RFuture<Void> lockAsync(long var1); //var1为线程id
    RFuture<Void> lockAsync(long var1, TimeUnit var3);   //锁超时时间
    RFuture<Void> lockAsync(long var1, TimeUnit var3, long var4);
                     //异步加锁，超时时间var1，时间单位var3，var4为线程id

    RFuture<Boolean> tryLockAsync();
    RFuture<Boolean> tryLockAsync(long var1);   //var1为线程id
    RFuture<Boolean> tryLockAsync(long var1, TimeUnit var3);  //锁超时时间
    RFuture<Boolean> tryLockAsync(long var1, long var3, TimeUnit var5);  //锁等待时间，超时时间
    RFuture<Boolean> tryLockAsync(long var1, long var3, TimeUnit var5, long var6);
                     //异步尝试加锁，等待时间var1，锁超时时间var3，时间单位var5，var6为线程id

    RFuture<Void> unlockAsync();
    RFuture<Void> unlockAsync(long var1);   //释放锁

    RFuture<Boolean> forceUnlockAsync();    //强制释放锁

    RFuture<Integer> getHoldCountAsync();   //持有锁的线程数
    RFuture<Boolean> isLockedAsync();       //锁是否被占有
    RFuture<Long> remainTimeToLiveAsync();  //所得剩余时间
}

 

 

*********************

示例

 

public class MyTest2 {

    public static void main(String[] args){
        Config config=new Config();
        config.useSingleServer().setAddress("redis://***:6379").setPassword("123456");
        RedissonClient client= Redisson.create(config);
        RLock lock=client.getLock("lock");

        ExecutorService executorService= Executors.newFixedThreadPool(5);
        for (int i=0;i<10;i++){
            executorService.submit(()->{
               try{
                   lock.lock(1, TimeUnit.SECONDS);
                   System.out.println("线程 "+Thread.currentThread().getId()+" 获得锁："+System.currentTimeMillis());
                   Thread.sleep(4000);
               }catch (Exception e){
                   e.printStackTrace();
               }finally {
                   System.out.println("线程"+Thread.currentThread().getId()+"释放锁："+System.currentTimeMillis());
                   lock.forceUnlock();
               }
            });
        }
        System.out.println(lock.getName());
        System.out.println(lock.getHoldCount());
    }
}

 

*********************

控制台输出

 

线程 49 获得锁：1574600045851
线程 49 释放锁：1574600049854

线程 49 获得锁：1574600049872
线程 49 释放锁：1574600053876

线程 49 获得锁：1574600053897
线程 49 释放锁：1574600057897

线程 49 获得锁：1574600057903
线程 49 释放锁：1574600061904

线程 49 获得锁：1574600061925
线程 49 释放锁：1574600065928

线程 49 获得锁：1574600065933
线程 49 释放锁：1574600069936

线程 50 获得锁：1574600069945
线程 50 释放锁：1574600073947

线程 48 获得锁：1574600073955
线程 48 释放锁：1574600077958

线程 51 获得锁：1574600077970
线程 51 释放锁：1574600081972

线程 52 获得锁：1574600081993
线程 52 释放锁：1574600085995