Comment utiliser la stratégie d'élimination du cache Redis et les transactions pour implémenter le verrouillage optimiste

Stratégie d'élimination du cache

Principe du titre LRU

L'algorithme LRU (le moins récemment utilisé, le moins récemment utilisé) élimine les données en fonction des enregistrements d'accès historiques aux données. L'idée principale est "Si les données ont été consultées récemment. , alors les chances d'être visité à l'avenir sont également plus élevées.

L'implémentation la plus courante consiste à utiliser une liste chaînée pour enregistrer les données mises en cache. L'algorithme détaillé est implémenté comme suit :

• Les nouvelles données sont insérées dans l'en-tête de la liste chaînée ; Chaque fois que le cache est activé (c'est-à-dire que les données mises en cache sont accessibles) ), déplacez les données vers la tête de la liste chaînée ;

• Lorsque la liste chaînée est pleine, supprimez les données à la fin de la liste chaînée.

• Vous pouvez utiliser LinkHashMap en Java pour implémenter LRU à l'aide de l'implémentation de liste chaînée de hachage :

Titre Stratégie d'élimination du cache Redis

Définir le cache maximum

Dans Redis, les utilisateurs sont autorisés à définir le maximum taille de la mémoire utilisée maxmemory, la valeur par défaut est 0 et le cache maximum n'est pas spécifié. Si de nouvelles données sont ajoutées et dépassent la mémoire maximale, redis plantera, il doit donc être défini.

redis Lorsque la taille de l'ensemble de données en mémoire augmente jusqu'à une certaine taille, la stratégie d'élimination des données sera mise en œuvre.

Stratégie d'élimination

Configuration de la stratégie d'élimination de redis : maxmemory-policy voltile-lru, prend en charge la configuration à chaud

redis propose 6 stratégies d'élimination de données :

volatile-lru :

À partir du délai d'expiration défini, sélectionnez les données les moins récemment utilisées de l'ensemble de données (server.db[i].expires) pour éliminer

• volatile-ttl :

  De l'ensemble de données (server.db[i].expires) avec un délai d'expiration défini Sélectionnez les données qui expireront et éliminez-les

• volatile-random :

  Sélectionnez aléatoirement les données à éliminer de l'ensemble de données (server.db[i].expires) qui a défini un délai d'expiration

• allkeys -lru :

  From Sélectionnez les données les moins récemment utilisées de l'ensemble de données (server.db[i].dict) pour éliminer

• allkeys-random :

  Sélectionnez toutes les données de l'ensemble de données (server.db[i]. ].dict) pour éliminer

• no-enviction (expulsion):

  Aucune expulsion de données

• Transaction Redis

  Introduction aux transactions Redis

Les transactions Redis sont effectuées via les cinq commandes MULTI, EXEC , JETER et REGARDER et NE PAS REGARDER .

• Une seule commande de Redis est atomique, vous devez donc ici vous assurer que l'objet transactionnel est un ensemble de commandes.

• Redis sérialise l'ensemble de commandes et assure l'exécution continue et ininterrompue de l'ensemble de commandes dans la même transaction

• Redis ne prend pas en charge les opérations de restauration. La commande de transaction

• MULTI
  est utilisée pour marquer le début d'un bloc de transaction. Redis mettra les commandes suivantes dans la file d'attente une par une, puis utilisera la commande atomique EXEC pour exécuter cette séquence de commandes. ... Mettez la commande en file d'attente, puis reprenez l'état de connexion normal.

Syntaxe :

multi

WATCH

Lorsqu'une [transaction doit être exécutée sous condition], utilisez cette commande pour définir le statut [clé à surveiller] donné.

Syntaxe :

exec

Remarques : Utilisez cette commande pour implémenter le verrouillage optimiste de Redis.

UNWATCH

Effacer toutes les clés précédemment surveillées pour une transaction

Syntaxe :

discard

Illustration de la commande :

Démonstration de la transaction :

watch key [key…]

Redis ne le fait pas prendre en charge l'annulation des transactions (pourquoi encore)

La plupart des échecs de transaction sont dus à des erreurs de syntaxe ou à des erreurs de type. Ces deux erreurs sont prévisibles pendant la phase de développement. Redis ignore l'annulation des transactions pour des raisons de performances.

Redis Optimistic Lock

Le verrouillage optimiste est basé sur l'idée CAS (Compare And Swap) (comparer et remplacer). Il ne s'exclut pas mutuellement et ne provoquera pas d'attente de verrouillage et ne consommera pas de ressources. Cependant, il nécessite des tentatives répétées, mais cela. C'est aussi grâce aux nouvelles tentatives que le mécanisme d'essai peut répondre plus rapidement. Par conséquent, nous pouvons utiliser Redis pour implémenter le verrouillage optimiste. L'idée spécifique est la suivante :

Utilisez la fonction de surveillance de redis pour surveiller la valeur d'état de cette redisKey

Obtenez la valeur de redisKey

Créez une transaction redis

Donnez la valeur de cette clé +1

然后去执行这个事务，如果key的值被修改过则回滚，key不加1

public void watch() {
	try {
		String watchKeys = "watchKeys";
		//初始值 value=1
		jedis.set(watchKeys, 1);
		//监听key为watchKeys的值
		jedis.watch(watchkeys);
		//开启事务
		Transaction tx = jedis.multi();
		//watchKeys自增加一
		tx.incr(watchKeys);
		//执行事务，如果其他线程对watchKeys中的value进行修改，则该事务将不会执行
		//通过redis事务以及watch命令实现乐观锁
		List<Object> exec = tx.exec();
		if (exec == null) {
			System.out.println("事务未执行");
		} else {
			System.out.println("事务成功执行，watchKeys的value成功修改");
		}
	} catch (Exception e) {
		e.printStackTrace();
	} finally {
		jedis.close();
	}
}

Redis乐观锁实现秒杀

public class RedisLock {
    public static void main(String[] arg) {
        //库存key 
        String redisKey = "stock";
        ExecutorService executorService = Executors.newFixedThreadPool(20);
        try {
            Jedis jedis = new RedisProperties.Jedis("127.0.0.1", 6378);
            // 可以被秒杀的库存的初始值，库存总共20个
            jedis.set(redisKey, "0");
            jedis.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        for (int i = 0; i < 1000; i++) {
            executorService.execute(() -> {
                Jedis jedis1 = new Jedis("127.0.0.1", 6378);
                try {
                    jedis1.watch(redisKey);
                    String redisValue = jedis1.get(redisKey);
                    int valInteger = Integer.valueOf(redisValue);
                    String userInfo = UUID.randomUUID().toString();
                    // 没有秒完
                    if (valInteger < 20) {
                        Transaction tx = jedis1.multi();
                        tx.incr(redisKey);
                        List list = tx.exec();
                        // 秒成功 失败返回空list而不是空
                        if (list != null && list.size() > 0) {
                            System.out.println("用户：" + userInfo + "，秒杀成 功！当前成功人数：" + (valInteger + 1));
                        }
                        // 版本变化，被别人抢了。
                        else {
                            System.out.println("用户：" + userInfo + "，秒杀失 败");
                        }
                    }
                    // 秒完了
                    else {
                        System.out.println("已经有20人秒杀成功，秒杀结束");
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    jedis1.close();
                }
            });
        }
        executorService.shutdown();
    }
}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!