分佈式鎖專題-Redisson分佈式鎖實現

1.Redisson簡介

Redis 是最流行的 NoSQL 數據庫解決方案之一，而 Java 是世界上最流行（注意，我沒有說“最好”）的編程語言之一。雖然兩者看起來很自然地在一起“工作”，但是要知道，Redis 其實並沒有對 Java 提供原生支持。

相反，作爲 Java 開發人員，我們若想在程序中集成 Redis，必須使用 Redis 的第三方庫。而 Redisson 就是用於在 Java 程序中操作 Redis 的庫，它使得我們可以在程序中輕鬆地使用 Redis。Redisson 在 java.util 中常用接口的基礎上，爲我們提供了一系列具有分佈式特性的工具類。

Redisson底層採用的是Netty 框架。支持Redis 2.8以上版本，支持Java1.6+以上版本。

2.Redisson實現分佈式鎖的步驟

2.1.引入依賴

引入重要的兩個依賴，一個是spring-boot-starter-data-redis，一個是redisson：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.7.5</version>
</dependency>

2.2.application.properties

# Redis服務器地址（默認session使用）
spring.redis.host=127.0.0.1
# Redis服務器連接密碼（默認爲空）
# spring.redis.password=
# Redis服務器連接端口
spring.redis.port=6379

2.3.定義Loker

接口編程的思想還是要保持的。我們定義一個Loker接口，用於分佈式鎖的一些操作：

package com.bruceliu.lock;

/**
 * @BelongsProject: RedissonLock
 * @BelongsPackage: com.bruceliu.lock
 * @Author: bruceliu
 * @QQ:1241488705
 * @CreateTime: 2020-05-08 10:20
 * @Description: 鎖接口
 */
import java.util.concurrent.TimeUnit;

public interface Locker {

    /**
     * 獲取鎖，如果鎖不可用，則當前線程處於休眠狀態，直到獲得鎖爲止。
     *
     * @param lockKey
     */
    void lock(String lockKey);

    /**
     * 釋放鎖
     *
     * @param lockKey
     */
    void unlock(String lockKey);

    /**
     * 獲取鎖,如果鎖不可用，則當前線程處於休眠狀態，直到獲得鎖爲止。如果獲取到鎖後，執行結束後解鎖或達到超時時間後會自動釋放鎖
     *
     * @param lockKey
     * @param timeout
     */
    void lock(String lockKey, int timeout);

    /**
     * 獲取鎖,如果鎖不可用，則當前線程處於休眠狀態，直到獲得鎖爲止。如果獲取到鎖後，執行結束後解鎖或達到超時時間後會自動釋放鎖
     *
     * @param lockKey
     * @param unit
     * @param timeout
     */
    void lock(String lockKey, TimeUnit unit, int timeout);

    /**
     * 嘗試獲取鎖，獲取到立即返回true,未獲取到立即返回false
     *
     * @param lockKey
     * @return
     */
    boolean tryLock(String lockKey);

    /**
     * 嘗試獲取鎖，在等待時間內獲取到鎖則返回true,否則返回false,如果獲取到鎖，則要麼執行完後程序釋放鎖，
     * 要麼在給定的超時時間leaseTime後釋放鎖
     *
     * @param lockKey
     * @param waitTime
     * @param leaseTime
     * @param unit
     * @return
     */
    boolean tryLock(String lockKey, long waitTime, long leaseTime, TimeUnit unit)
            throws InterruptedException;

    /**
     * 鎖是否被任意一個線程鎖持有
     *
     * @param lockKey
     * @return
     */
    boolean isLocked(String lockKey);
}

有了Locker接口，我們再添加一個基於Redisson的實現類RedissonLocker，實現Locker中的方法：

package com.bruceliu.lock;

/**
 * @BelongsProject: RedissonLock
 * @BelongsPackage: com.bruceliu.lock
 * @Author: bruceliu
 * @QQ:1241488705
 * @CreateTime: 2020-05-08 10:20
 * @Description: 基於Redisson的分佈式鎖
 */
import java.util.concurrent.TimeUnit;

import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;

public class RedissonLocker implements Locker {

    private RedissonClient redissonClient;

    public RedissonLocker(RedissonClient redissonClient) {
        super();
        this.redissonClient = redissonClient;
    }

    @Override
    public void lock(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.lock();
    }

    @Override
    public void unlock(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.unlock();
    }

    @Override
    public void lock(String lockKey, int leaseTime) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.lock(leaseTime, TimeUnit.SECONDS);
    }

    @Override
    public void lock(String lockKey, TimeUnit unit, int timeout) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.lock(timeout, unit);
    }

    public void setRedissonClient(RedissonClient redissonClient) {
        this.redissonClient = redissonClient;
    }

    @Override
    public boolean tryLock(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        return lock.tryLock();
    }

    @Override
    public boolean tryLock(String lockKey, long waitTime, long leaseTime,
                           TimeUnit unit) throws InterruptedException{
        RLock lock = redissonClient.getLock(lockKey);
        return lock.tryLock(waitTime, leaseTime, unit);
    }

    @Override
    public boolean isLocked(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        return lock.isLocked();
    }

}

2.4.定義工具類

有了Locker和實現類RedissonLocker，我們總不能一直去創建RedissonLocker對象或者不斷的在每個要使用到分佈式鎖的地方都注入RedissonLocker的對象，所以我們定義一個工具類LockUtil，到時候想哪裏使用就直接使用工具類的靜態方法就行了：

package com.bruceliu.utils;

/**
 * @BelongsProject: RedissonLock
 * @BelongsPackage: com.bruceliu.utils
 * @Author: bruceliu
 * @QQ:1241488705
 * @CreateTime: 2020-05-08 10:21
 * @Description: TODO
 */
import com.bruceliu.lock.Locker;

import java.util.concurrent.TimeUnit;

/**
 * redis分佈式鎖工具類
 *
 */
public final class LockUtil {

    private static Locker locker;

    /**
     * 設置工具類使用的locker
     * @param locker
     */
    public static void setLocker(Locker locker) {
        LockUtil.locker = locker;
    }

    /**
     * 獲取鎖
     * @param lockKey
     */
    public static void lock(String lockKey) {
        locker.lock(lockKey);
    }

    /**
     * 釋放鎖
     * @param lockKey
     */
    public static void unlock(String lockKey) {
        locker.unlock(lockKey);
    }

    /**
     * 獲取鎖，超時釋放
     * @param lockKey
     * @param timeout
     */
    public static void lock(String lockKey, int timeout) {
        locker.lock(lockKey, timeout);
    }

    /**
     * 獲取鎖，超時釋放，指定時間單位
     * @param lockKey
     * @param unit
     * @param timeout
     */
    public static void lock(String lockKey, TimeUnit unit, int timeout) {
        locker.lock(lockKey, unit, timeout);
    }

    /**
     * 嘗試獲取鎖，獲取到立即返回true,獲取失敗立即返回false
     * @param lockKey
     * @return
     */
    public static boolean tryLock(String lockKey) {
        return locker.tryLock(lockKey);
    }

    /**
     * 嘗試獲取鎖，在給定的waitTime時間內嘗試，獲取到返回true,獲取失敗返回false,獲取到後再給定的leaseTime時間超時釋放
     * @param lockKey
     * @param waitTime
     * @param leaseTime
     * @param unit
     * @return
     * @throws InterruptedException
     */
    public static boolean tryLock(String lockKey, long waitTime, long leaseTime,
                                  TimeUnit unit) throws InterruptedException {
        return locker.tryLock(lockKey, waitTime, leaseTime, unit);
    }

    /**
     * 鎖釋放被任意一個線程持有
     * @param lockKey
     * @return
     */
    public static boolean isLocked(String lockKey) {
        return locker.isLocked(lockKey);
    }
}

2.5.Redisson的配置類

現在我們開始配置吧，創建一個redisson的配置類RedissonConfig，內容如下：

package com.bruceliu.config;

import java.io.IOException;

import com.bruceliu.lock.RedissonLocker;
import com.bruceliu.utils.LockUtil;
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @BelongsProject: RedissonLock
 * @BelongsPackage: com.bruceliu.config
 * @Author: bruceliu
 * @QQ:1241488705
 * @CreateTime: 2020-05-08 10:22
 * @Description: TODO
 */
@Configuration
public class RedissonConfig {

    @Value("${spring.redis.host}")
    private String host;

    @Value("${spring.redis.port}")
    private String port;

    //@Value("${spring.redis.password}")
    //private String password;

    /**
     * RedissonClient,單機模式
     * @return
     * @throws IOException
     */
    @Bean(destroyMethod = "shutdown")
    public RedissonClient redisson() throws IOException {
        Config config = new Config();
        //config.useSingleServer().setAddress("redis://" + host + ":" + port).setPassword(password);
        config.useSingleServer().setAddress("redis://" + host + ":" + port);
        return Redisson.create(config);
    }

    @Bean
    public RedissonLocker redissonLocker(RedissonClient redissonClient){
        RedissonLocker locker = new RedissonLocker(redissonClient);
        //設置LockUtil的鎖處理對象
        LockUtil.setLocker(locker);
        return locker;
    }
}

2.6.Redisson分佈式鎖業務類

package com.bruceliu.service;

import com.bruceliu.utils.LockUtil;

import java.util.concurrent.TimeUnit;

/**
 * @BelongsProject: RedissonLock
 * @BelongsPackage: com.bruceliu.service
 * @Author: bruceliu
 * @QQ:1241488705
 * @CreateTime: 2020-05-08 10:26
 * @Description: TODO
 */
public class SkillService {

    int n = 500;

    public void seckill() {
        //加鎖
        LockUtil.lock("resource", TimeUnit.SECONDS,5000);
        try {
            System.out.println(Thread.currentThread().getName() + "獲得了鎖");
            Thread.sleep(3000);
            System.out.println(--n);
        } catch (Exception e) {
            //異常處理
        }finally{
            //釋放鎖
            LockUtil.unlock("resource");
            System.out.println(Thread.currentThread().getName() + "釋放了鎖");
        }
    }
}

2.7.Redisson分佈式鎖測試

package com.bruceliu.test;

import com.bruceliu.App;
import com.bruceliu.service.SkillService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

/**
 * @BelongsProject: RedissonLock
 * @BelongsPackage: com.bruceliu.test
 * @Author: bruceliu
 * @QQ:1241488705
 * @CreateTime: 2020-05-08 10:29
 * @Description: TODO
 */
@RunWith(SpringRunner.class)
@SpringBootTest(classes = App.class)
public class TestLock {

    @Test
    public void testLock() throws Exception{
        SkillService service = new SkillService();
        for (int i = 0; i < 10; i++) {
            ThreadA threadA = new ThreadA(service);
            threadA.setName("ThreadNameA->"+i);
            threadA.start();
        }
        Thread.sleep(50000);
    }

}

class ThreadA extends Thread {

    private SkillService skillService;

    public ThreadA(SkillService skillService) {
        this.skillService = skillService;
    }

    @Override
    public void run() {
        skillService.seckill();
    }
}

運行結果:

註釋文中加鎖代碼：

public void seckill() {
    //加鎖
    //LockUtil.lock("resource", TimeUnit.SECONDS,5000);
    try {
        System.out.println(Thread.currentThread().getName() + "獲得了鎖");
        Thread.sleep(3000);
        System.out.println(--n);
    } catch (Exception e) {
        //異常處理
    }finally{
        //釋放鎖
        //LockUtil.unlock("resource");
        System.out.println(Thread.currentThread().getName() + "釋放了鎖");
    }
}

運行結果：

可以看到存在併發的問題！

分佈式鎖專題-Redisson分佈式鎖實現

1.Redisson簡介

2.Redisson實現分佈式鎖的步驟

2.1.引入依賴

2.2.application.properties

2.3.定義Loker

2.4.定義工具類

2.5.Redisson的配置類

2.6.Redisson分佈式鎖業務類

2.7.Redisson分佈式鎖測試

多線程專題-生產者消費者問題

IO流專題-序列化

IO流專題-緩衝流

IO流專題-字符流

IO流專題-FIle類和遞歸

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結