Ringkasan lima kaedah untuk melaksanakan kunci teragih dalam Redis

Artikel ini membawa anda pengetahuan yang berkaitan tentang Redis Dalam seni bina yang diedarkan, kami juga akan menghadapi masalah operasi perkongsian data untuk menyelesaikan konsistensi data dalam seni bina yang diedarkan masalah. Saya harap ia akan membantu semua orang.

Pembelajaran yang disyorkan: Tutorial video Redis

Dalam satu aplikasi, jika kami tidak mengunci data yang dikongsi, Masalah ketekalan data akan timbul, dan penyelesaian kami biasanya menguncinya.

Dalam seni bina teragih, kami juga akan menghadapi masalah operasi perkongsian data Artikel ini menggunakan Redis untuk menyelesaikan masalah ketekalan data dalam seni bina teragih.

1. Konsistensi data mesin tunggal

Seni bina ketekalan data mesin tunggal ditunjukkan dalam rajah di bawah: berbilang pelanggan boleh mengakses pelayan yang sama dan menyambung ke pangkalan data yang sama.

Perihalan senario: Pelanggan mensimulasikan proses pembelian barangan dan menetapkan jumlah inventori yang tinggal dalam Redis kepada 100个 Pembelian berbilang pelanggan serentak pada masa yang sama masa.

@RestController
public class IndexController1 {

    @Autowired
    StringRedisTemplate template;

    @RequestMapping("/buy1")
    public String index(){
        // Redis中存有goods:001号商品，数量为100
        String result = template.opsForValue().get("goods:001");
        // 获取到剩余商品数
        int total = result == null ? 0 : Integer.parseInt(result);
        if( total > 0 ){
            // 剩余商品数大于0 ，则进行扣减
            int realTotal = total -1;
            // 将商品数回写数据库
            template.opsForValue().set("goods:001",String.valueOf(realTotal));
            System.out.println("购买商品成功，库存还剩："+realTotal +"件， 服务端口为8001");
            return "购买商品成功，库存还剩："+realTotal +"件， 服务端口为8001";
        }else{
            System.out.println("购买商品失败，服务端口为8001");
        }
        return "购买商品失败，服务端口为8001";
    }
}

Gunakan Jmeter untuk mensimulasikan senario konkurensi tinggi Keputusan ujian adalah seperti berikut:

. Keputusan ujian nampaknya berbilang Pengguna yang membeli produk yang sama, dan masalah ketidakkonsistenan data berlaku!

Penyelesaian: Dalam kes satu aplikasi, kunci operasi serentak untuk memastikan operasi data adalah atom

• synchronized
• ReentrantLock

@RestController
public class IndexController2 {
// 使用ReentrantLock锁解决单体应用的并发问题
Lock lock = new ReentrantLock();

@Autowired
StringRedisTemplate template;

@RequestMapping("/buy2")
public String index() {

    lock.lock();
    try {
        String result = template.opsForValue().get("goods:001");
        int total = result == null ? 0 : Integer.parseInt(result);
        if (total > 0) {
            int realTotal = total - 1;
            template.opsForValue().set("goods:001", String.valueOf(realTotal));
            System.out.println("购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001");
            return "购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001";
        } else {
            System.out.println("购买商品失败，服务端口为8001");
        }
    } catch (Exception e) {
        lock.unlock();
    } finally {
        lock.unlock();
    }
    return "购买商品失败，服务端口为8001";
}
}

2. Ketekalan data teragih

Perkara di atas menyelesaikan masalah ketekalan data bagi aplikasi tunggal Tetapi jika ia adalah penyebaran seni bina seni bina adalah seperti berikut:

menyediakan dua perkhidmatan, port adalah 8001 dan 8002, disambungkan kepada perkhidmatan Redis yang sama, terdapat Nginx di hadapan perkhidmatan Sebagai pengimbangan beban

kedua-dua kod perkhidmatan adalah sama, tetapi portnya berbeza

mulakan dua perkhidmatan 8001 dan 8002, dan setiap perkhidmatan masih kekal Gunakan ReentrantLock untuk mengunci, gunakan Jmeter untuk melakukan ujian serentak dan mendapati bahawa masalah konsistensi data akan berlaku!

3. Redis melaksanakan kunci teragih

3.1 Kaedah 1

Batalkan kunci bersendirian, gunakan redis's set di bawah Perintah untuk melaksanakan penguncian teragih

SET NILAI KUNCI [EX saat] [PX milisaat] [NX|XX]

• EX saat Tetapkan masa tamat tempoh yang ditentukan (dalam saat Unit)
• PX milisaat Tetapkan masa tamat tempoh yang ditentukan dalam milisaat
• NX Tetapkan kunci hanya jika kunci tidak wujud
• XX Hanya jika kunci sudah wujud Kod di atas ditetapkan up

@RestController
public class IndexController4 {

    // Redis分布式锁的key
    public static final String REDIS_LOCK = "good_lock";

    @Autowired
    StringRedisTemplate template;

    @RequestMapping("/buy4")
    public String index(){

        // 每个人进来先要进行加锁，key值为"good_lock"，value随机生成
        String value = UUID.randomUUID().toString().replace("-","");
        try{
            // 加锁
            Boolean flag = template.opsForValue().setIfAbsent(REDIS_LOCK, value);
            // 加锁失败
            if(!flag){
                return "抢锁失败！";
            }
            System.out.println( value+ " 抢锁成功");
            String result = template.opsForValue().get("goods:001");
            int total = result == null ? 0 : Integer.parseInt(result);
            if (total > 0) {
                int realTotal = total - 1;
                template.opsForValue().set("goods:001", String.valueOf(realTotal));
                // 如果在抢到所之后，删除锁之前，发生了异常，锁就无法被释放，
                // 释放锁操作不能在此操作，要在finally处理
				// template.delete(REDIS_LOCK);
                System.out.println("购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001");
                return "购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001";
            } else {
                System.out.println("购买商品失败，服务端口为8001");
            }
            return "购买商品失败，服务端口为8001";
        }finally {
            // 释放锁
            template.delete(REDIS_LOCK);
        }
    }
}

untuk menyelesaikan masalah ketekalan data dalam seni bina teragih. Tetapi jika anda memikirkannya dengan lebih teliti, masih akan ada masalah Mari buat penambahbaikan di bawah.

3.2 Kaedah 2 (Kaedah Penambahbaikan 1)

Dalam kod di atas, jika mesin di mana pakej perkhidmatan mikro jar digunakan tiba-tiba digantung semasa menjalankan program, tahap kod akan bukan Blok kod finally belum dicapai, yang bermaksud bahawa kunci belum dipadamkan sebelum penutupan Dalam kes ini, tiada cara untuk menjamin membuka kunci

Oleh itu, kita perlu menambah tarikh tamat tempoh kepada key ini, terdapat dua cara untuk menetapkan masa tamat tempoh dalam Redis:

• template.expire(REDIS_LOCK,10, TimeUnit.SECONDS)
• template.opsForValue().setIfAbsent(REDIS_LOCK, value,10L,TimeUnit.SECONDS)

Kaedah pertama memerlukan baris kod A yang berasingan, dan ia tidak diletakkan dalam langkah yang sama seperti mengunci, jadi ia bukan atom dan akan menyebabkan masalah

Kaedah kedua menetapkan masa tamat tempoh pada masa yang sama seperti mengunci, jadi tidak ada Masalah, di sini kami menggunakan kaedah ini

untuk melaraskan kod dan menetapkan masa tamat tempoh semasa mengunci:

// 为key加一个过期时间，其余代码不变
Boolean flag = template.opsForValue().setIfAbsent(REDIS_LOCK,value,10L,TimeUnit.SECONDS);

Kaedah ini menyelesaikan masalah menjadi tidak dapat melepaskan kunci kerana masalah masa tidak berfungsi secara tiba-tiba. Tetapi jika anda memikirkannya dengan lebih teliti, masih akan ada masalah Mari buat penambahbaikan di bawah.

3.3 Kaedah 3 (Kaedah Diperbaiki 2)

Kaedah 2 menetapkan masa tamat tempoh key, yang menyelesaikan masalah yang key tidak boleh dipadamkan, tetapi masalah itu datang lagi

上面设置了key的过期时间为10秒，如果业务逻辑比较复杂，需要调用其他微服务，处理时间需要15秒（模拟场

景，别较真），而当10秒钟过去之后，这个key就过期了，其他请求就又可以设置这个key，此时如果耗时15秒

的请求处理完了，回来继续执行程序，就会把别人设置的key给删除了，这是个很严重的问题！

所以，谁上的锁，谁才能删除

@RestController
public class IndexController6 {

    public static final String REDIS_LOCK = "good_lock";

    @Autowired
    StringRedisTemplate template;

    @RequestMapping("/buy6")
    public String index(){

        // 每个人进来先要进行加锁，key值为"good_lock"
        String value = UUID.randomUUID().toString().replace("-","");
        try{
            // 为key加一个过期时间
            Boolean flag = template.opsForValue().setIfAbsent(REDIS_LOCK, value,10L,TimeUnit.SECONDS);

            // 加锁失败
            if(!flag){
                return "抢锁失败！";
            }
            System.out.println( value+ " 抢锁成功");
            String result = template.opsForValue().get("goods:001");
            int total = result == null ? 0 : Integer.parseInt(result);
            if (total > 0) {
                // 如果在此处需要调用其他微服务，处理时间较长。。。
                int realTotal = total - 1;
                template.opsForValue().set("goods:001", String.valueOf(realTotal));
                System.out.println("购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001");
                return "购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001";
            } else {
                System.out.println("购买商品失败，服务端口为8001");
            }
            return "购买商品失败，服务端口为8001";
        }finally {
            // 谁加的锁，谁才能删除！！！！
            if(template.opsForValue().get(REDIS_LOCK).equals(value)){
                template.delete(REDIS_LOCK);
            }
        }
    }
}

这种方式解决了因服务处理时间太长而释放了别人锁的问题。这样就没问题了吗？

3.4 方式四（改进方式三）

在上面方式三下，规定了谁上的锁，谁才能删除，但finally快的判断和del删除操作不是原子操作，并发的时候也会出问题，并发嘛，就是要保证数据的一致性，保证数据的一致性，最好要保证对数据的操作具有原子性。

在Redis的set命令介绍中，最后推荐Lua脚本进行锁的删除，地址

@RestController
public class IndexController7 {

    public static final String REDIS_LOCK = "good_lock";

    @Autowired
    StringRedisTemplate template;

    @RequestMapping("/buy7")
    public String index(){

        // 每个人进来先要进行加锁，key值为"good_lock"
        String value = UUID.randomUUID().toString().replace("-","");
        try{
            // 为key加一个过期时间
            Boolean flag = template.opsForValue().setIfAbsent(REDIS_LOCK, value,10L,TimeUnit.SECONDS);
            // 加锁失败
            if(!flag){
                return "抢锁失败！";
            }
            System.out.println( value+ " 抢锁成功");
            String result = template.opsForValue().get("goods:001");
            int total = result == null ? 0 : Integer.parseInt(result);
            if (total > 0) {
                // 如果在此处需要调用其他微服务，处理时间较长。。。
                int realTotal = total - 1;
                template.opsForValue().set("goods:001", String.valueOf(realTotal));
                System.out.println("购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001");
                return "购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001";
            } else {
                System.out.println("购买商品失败，服务端口为8001");
            }
            return "购买商品失败，服务端口为8001";
        }finally {
            // 谁加的锁，谁才能删除，使用Lua脚本，进行锁的删除

            Jedis jedis = null;
            try{
                jedis = RedisUtils.getJedis();

                String script = "if redis.call('get',KEYS[1]) == ARGV[1] " +
                        "then " +
                        "return redis.call('del',KEYS[1]) " +
                        "else " +
                        "   return 0 " +
                        "end";

                Object eval = jedis.eval(script, Collections.singletonList(REDIS_LOCK), Collections.singletonList(value));
                if("1".equals(eval.toString())){
                    System.out.println("-----del redis lock ok....");
                }else{
                    System.out.println("-----del redis lock error ....");
                }
            }catch (Exception e){

            }finally {
                if(null != jedis){
                    jedis.close();
                }
            }
        }
    }
}

3.5 方式五（改进方式四）

在方式四下，规定了谁上的锁，谁才能删除，并且解决了删除操作没有原子性问题。但还没有考虑缓存续命，以及Redis集群部署下，异步复制造成的锁丢失：主节点没来得及把刚刚set进来这条数据给从节点，就挂了。所以直接上RedLock的Redisson落地实现。

@RestController
public class IndexController8 {

    public static final String REDIS_LOCK = "good_lock";

    @Autowired
    StringRedisTemplate template;

    @Autowired
    Redisson redisson;

    @RequestMapping("/buy8")
    public String index(){

        RLock lock = redisson.getLock(REDIS_LOCK);
        lock.lock();

        // 每个人进来先要进行加锁，key值为"good_lock"
        String value = UUID.randomUUID().toString().replace("-","");
        try{
            String result = template.opsForValue().get("goods:001");
            int total = result == null ? 0 : Integer.parseInt(result);
            if (total > 0) {
                // 如果在此处需要调用其他微服务，处理时间较长。。。
                int realTotal = total - 1;
                template.opsForValue().set("goods:001", String.valueOf(realTotal));
                System.out.println("购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001");
                return "购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001";
            } else {
                System.out.println("购买商品失败，服务端口为8001");
            }
            return "购买商品失败，服务端口为8001";
        }finally {
            if(lock.isLocked() && lock.isHeldByCurrentThread()){
                lock.unlock();
            }
        }
    }
}

推荐学习：Redis视频教程

Atas ialah kandungan terperinci Ringkasan lima kaedah untuk melaksanakan kunci teragih dalam Redis. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!