Comment implémenter le cache distribué Redis et la vente flash

1. Problèmes avec Redis à point unique

1. Problème de perte de données

Persistance des données Redis.

2. Problème de concurrence

Nous utilisons des clusters maître-esclave pour réaliser la séparation de la lecture et de l'écriture.

3. Problème de récupération en cas d'échec

Utilisez Redis Sentinel pour réaliser une détection de l'état et une récupération automatique.

4. Problème de capacité de stockage

Construisez un cluster fragmenté et utilisez le mécanisme de slot pour réaliser une expansion dynamique.

2. RDB

RDB signifie Redis Database Backup file (fichier de sauvegarde de données Redis), également appelé instantané de données Redis. Pour faire simple, toutes les données de la mémoire sont enregistrées sur le disque. Lorsque l'instance Redis échoue et redémarre, le fichier d'instantané est lu à partir du disque et les données sont restaurées.
Les fichiers d'instantanés sont appelés fichiers RDB et sont enregistrés par défaut dans le répertoire d'exécution actuel.

Redis dispose d'un mécanisme interne pour déclencher RDB, qui se trouve dans le fichier redis.conf. Le format est le suivant :

Lorsque la commande bgsave est exécutée, un processus enfant sera créé via le système fork. appel, qui est partagé avec les données de la mémoire du processus principal. Après avoir terminé le fork, lisez les données de la mémoire et écrivez-les dans le fichier RDB.

fork utilise la technologie de copie sur écriture :

• Lorsque le processus principal effectue une opération de lecture, il accède à la mémoire partagée ;

• Lorsque le processus principal effectue une opération d'écriture, il copie une copie des données ; et effectue l'opération d'écriture

Le processus de base de bgsave en mode RDB ?

1. Fork le processus principal pour obtenir un processus enfant et partager l'espace mémoire ;

2. Le processus enfant lit les données de la mémoire et écrit le nouveau fichier RDB ;

3. Remplacez l'ancien fichier RDB par le nouveau RDB ; fichier ;

Quand RDB sera-t-il exécuté ? Que signifie économiser 60 1000 ?

• La valeur par défaut est lorsque le service est arrêté

• signifie que RDB est déclenché lorsqu'au moins 1000 modifications sont effectuées dans les 60 secondes

Les inconvénients de RDB ?

• L'intervalle d'exécution RDB est long et il existe un risque de perte de données entre deux écritures RDB ;

• Les sous-processus fork, la compression et l'écriture des fichiers RDB prennent tous du temps ; enregistrements de commande La fréquence peut également être configurée via le fichier redis.conf :

3 AOF

AOF signifie Append Only File. Chaque commande d'écriture traitée par Redis sera enregistrée dans le fichier AOF, qui peut être considéré comme un fichier journal de commandes.

AOF est désactivé par défaut. Vous devez modifier le fichier de configuration redis.conf pour activer AOF :

La fréquence d'enregistrement des commandes AOF peut également être configurée via le fichier redis.conf :

Éléments de configuration Temps de flasher le disqueClignotage synchroneClignotant chaque secondeContrôle du système d'exploitation

Avantages

Inconvénients

Toujours

Haute fiabilité, presque aucune perte de données

Grand impact sur les performances

toutes les secondes

Performance modérée

Jusqu'à une minute de perte de données

non

Meilleures performances

Mauvaise fiabilité, perte possible de grandes quantités de données

Puisqu'il s'agit d'une commande d'enregistrement, le fichier AOF sera beaucoup plus volumineux que le fichier RDB. Bien que AOF enregistre plusieurs opérations d'écriture sur la même clé, seule la dernière opération d'écriture parmi elles est significative. Vous pouvez utiliser la commande bgrewriteaof pour compléter la fonction de réécriture de fichiers AOF avec le nombre minimum de commandes.

set id 1
set name nezha
set id 2

bgrewriteaof

mset name nezha id 2

Redis réécrira également automatiquement le fichier AOF lorsque le seuil est déclenché. Le seuil peut également être configuré dans redis.conf :

# Le pourcentage de croissance du fichier AOF par rapport au dernier fichier déclenchera une réécriture auto-aof-rewrite-percentage 100# La taille minimale du fichier AOF déclenchera une réécriture automatique. aof. -rewrite-min-size 64mb

RDB et AOF ont chacun leurs propres avantages et inconvénients Si les exigences en matière de sécurité des données sont élevées, ils sont souvent utilisés en combinaison dans le développement réel.

	RDB	AOF
Méthode de persistance	Instantanés réguliers de toute la mémoire	Enregistrer chaque commande exécutée
Intégrité des données	Incomplète , Deux sauvegardes Il sera perdu	relativement complet, selon la stratégie de brossage du disque
la taille du fichier	sera compressée, la taille du fichier est petite	commande d'enregistrement, la taille du fichier est grande
vitesse de récupération en cas d'arrêt	très rapide	Lent
Priorité de récupération des données	faible car l'intégrité des données n'est pas faible	Élevée car l'intégrité des données est plus élevée
Utilisation des ressources système	élevée, consommation importante de CPU et de mémoire	faible, principalement les ressources d'E/S disque , mais la réécriture AOF occupera beaucoup de ressources CPU et mémoire
Scénarios d'utilisation	Peut tolérer une perte de données pendant plusieurs minutes, poursuivre une vitesse de démarrage plus rapide	Exigences plus élevées en matière de sécurité des données Commun

4. Optimisation Redis Processus de vente flash

1. Étapes de la vente flash :

1. Rechercher des coupons

2. Vérifier l'inventaire des produits de la vente flash

3. Vérifier les commandes ; Réduire les stocks ;

4. Créer une commande ;

6. 2. Étapes de vente flash d'optimisation Redis :

Ajouter des coupons de vente flash et enregistrer les informations du coupon dans Redis ; inventaire des produits de vente flash, une personne en commande un et détermine si la vente flash de l'utilisateur est réussie

Si la vente flash réussit, l'identifiant du coupon, l'identifiant de l'utilisateur et l'identifiant du produit sont encapsulés dans la file d'attente de blocage ;

1. Activez les tâches asynchrones, lisez en continu les informations de la file d'attente de blocage et implémentez la commande asynchrone

3. Script Lua pour les ventes flash
4. 4. Appelez le script Lua pour les ventes flash

   public Result seckillVoucher(Long voucherId) {
        Long userId = UserHolder.getUser().getId();
        long orderId = redisIdWorker.nextId("order");
        // 1.执行lua脚本
        Long result = stringRedisTemplate.execute(
                SECKILL_SCRIPT,
                Collections.emptyList(),
                voucherId.toString(), userId.toString(), String.valueOf(orderId)
        );
        int r = result.intValue();
        // 2.判断结果是否为0
        if (r != 0) {
            // 2.1.不为0 ，代表没有购买资格
            return Result.fail(r == 1 ? "库存不足" : "不能重复下单");
        }
        // 3.返回订单id
        return Result.ok(orderId);
    }

   . 5. Grâce au pool de threads, l'opération bloque la file d'attente

// 线程池
private static final ExecutorService SECKILL_ORDER_EXECUTOR = Executors.newSingleThreadExecutor();

/**
* 在类初始化完成后执行
*/
@PostConstruct
private void init() {
    SECKILL_ORDER_EXECUTOR.submit(new VoucherOrderHandler());
}

// 阻塞队列
private BlockingQueue<VoucherOrder> orderTasks = new ArrayBlockingQueue<>(1024 * 1024);
private class OrderHandler implements Runnable{

    @Override
    public void run() {
        while (true){
            try {
                doSomething();
            } catch (Exception e) {
                log.error("处理订单异常", e);
            }
        }
    }
}

5. Connexion à une session partagée basée sur Redis

Connexion basée sur une session

Connexion à une session partagée basée sur Redis

public class RefreshTokenInterceptor implements HandlerInterceptor {

    private StringRedisTemplate stringRedisTemplate;

    public RefreshTokenInterceptor(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 1、获取请求头中的token
        String token = request.getHeader("authorization");
        if (StrUtil.isBlank(token)) {
            return true;
        }
        // 2、基于TOKEN获取redis中的用户
        String key  = LOGIN_USER_KEY + token;
        Map<Object, Object> userMap = stringRedisTemplate.opsForHash().entries(key);
        // 3、判断用户是否存在
        if (userMap.isEmpty()) {
            return true;
        }
        // 5、将查询到的hash数据转为UserDTO
        UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);
        // 6、存在，保存用户信息到 ThreadLocal
        UserHolder.saveUser(userDTO);
        // 7、刷新token有效期
        stringRedisTemplate.expire(key, LOGIN_USER_TTL, TimeUnit.MINUTES);
        // 8、放行
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        // 移除用户
        UserHolder.removeUser();
    }
}

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!