Redis est un système de stockage de structure de données de mémoire, principalement utilisé comme base de données, cache et courtier de messages. Ses caractéristiques principales incluent un modèle unique, un multiplexage d'E / S, un mécanisme de persistance, des fonctions de réplication et de clustering. Redis est couramment utilisé dans les applications pratiques pour la mise en cache, le stockage de session et les files d'attente de messages. Il peut améliorer considérablement ses performances en sélectionnant la bonne structure de données, en utilisant des pipelines et des transactions, et en surveillant et en réglage.

introduction

Redis, ce système de stockage de structure de données en mémoire, peut être familier avec cela, mais comprenez-vous vraiment son architecture et son objectif? Cet article vous amènera à explorer en profondeur la philosophie de conception de Redis et les scénarios d'application pratiques, vous aidant non seulement à ma?triser l'utilisation de base de Redis, mais aussi à comprendre l'essence du traitement des données haute performance.

Après avoir lu cet article, vous pourrez comprendre l'architecture de base de Redis, ma?triser les méthodes d'application dans les projets réels et être en mesure de sélectionner la structure de données Redis la plus appropriée en fonction des besoins spécifiques.

Redis Basics

Redis, nom de dictionnaire distant du nom complet, est un système de stockage de structure de données de mémoire open source. Il peut être utilisé comme courtier de base de données, de cache et de messages. Redis prend en charge une variété de structures de données, telles que des cha?nes, des tables de hachage, des listes, des collections et des collections ordonnées. Ces structures de données permettent à Redis de montrer ses compétences dans divers scénarios d'application.

La caractéristique principale de Redis est sa vitesse rapide, c'est-à-dire qu'elle stocke les données en mémoire. Son modèle unique et sa technologie de multiplexage d'E / S permettent à Redis de bien fonctionner lors de la gestion des demandes simultanées élevées.

Analyse de l'architecture redis

Modèle unique et multiplexage des E / S

Le modèle unique de Redis est l'un des noyau de son architecture. Le threading unique signifie que toutes les commandes de redis sont traitées par un thread, ce qui peut éviter la concurrence entre plusieurs threads et la complexité des verrous. Cependant, le filetage unique ne signifie pas que Redis a de mauvaises performances. Au contraire, Redis utilise la technologie de multiplexage des E / S pour réaliser une communication réseau efficace.

Le multiplexage d'E / S permet à Redis de gérer plusieurs connexions client dans un seul thread. Redis utilise le mécanisme de multiplexage d'E / S fourni par les systèmes d'exploitation tels que Epoll et Kqueue pour écouter les événements d'E / S de plusieurs descripteurs de fichiers. Lorsqu'un événement se produit, Redis effectuera l'opération correspondante en fonction du type d'événement. Cette méthode permet à Redis de gérer un grand nombre de connexions simultanées sous un seul thread, réalisant un traitement efficace des données.

 // Redis E / S Multiplexing Exemple int aecreateFileEvent (aeventloop * EventLoop, int fd, int mask,
        aeFileProc * proc, void * ClientData)
{
    if (fd> = eventloop-> setSize) {
        errno = errange;
        retourner ae_err;
    }
    aeFileEvent * fe = & eventloop-> événements [fd];

    if (aeapiaddevent (Eventloop, FD, masque) == -1)
        retourner ae_err;
    Fe-> masque | = masque;
    if (mask & ae_readable) fe-> rfileProc = proc;
    if (mask & ae_witable) fe-> wfileproc = proc;
    fe-> clientData = clientData;
    if (fd> eventloop-> maxfd)
        eventLoop-> maxfd = fd;
    retourner ae_ok;
}

Mécanisme de persistance

Redis fournit deux mécanismes de persistance: RDB et AOF. RDB enregistre les données sur le disque via des instantanés, tandis que AOF enregistre toutes les opérations d'écriture pour atteindre la persistance des données.

L'avantage des instantanés RDB est qu'ils sont une récupération rapide et conviennent aux sauvegardes à froid, mais leur inconvénient est qu'ils peuvent perdre des données récentes. AOF enregistre toutes les opérations d'écriture, les données sont plus complètes, mais la vitesse de récupération est relativement lente. Redis prend également en charge la fonction de réécriture AOF, qui peut compresser la taille des fichiers AOF sans affecter le service.

 // Exemple de snapshot rdb int rdbsave (char * filename) {
    dictiterator * di = null;
    dictry * de;
    Int J;
    Fichier * fp;
    char tmpfile [256];
    Long Long Now = mStime ();

    snprintf (tmpfile, 256, "temp-% d.rdb", (int) getpid ());
    fp = fopen (tmpfile, "w");
    if (! fp) {
        redislog (redis_warning, "ouverture échouée .rdb pour la sauvegarde:% s",
            STRERROR (ERRNO));
        return redis_err;
    }

    if (rdbsaverio (fp, 0, rdb_save_none) == redis_err) {
        fclose (FP);
        Unlink (tmpFile);
        return redis_err;
    }

    fclose (FP);
    if (renomment (tmpfile, nom de fichier) == -1) {
        redislog (redis_warning, "Erreur de déménagement du fichier db temporaire sur la destination finale:% s", strrror (errno));
        Unlink (tmpFile);
        return redis_err;
    }

    redislog (redis_notice, "db enregistré sur le disque");
    server.dirty = 0;
    server.LastSave = maintenant;
    return redis_ok;
}

Réplication et regroupement

La fonction de réplication de Redis permet à une instance redis (bibliothèque d'esclaves) de copier des données à partir d'une autre instance Redis (bibliothèque principale). Ce mécanisme peut non seulement mettre en ?uvre la sauvegarde redondante des données, mais également améliorer les performances des opérations de lecture, car la bibliothèque des esclaves peut partager les demandes de lecture de la bibliothèque principale.

Le cluster Redis élargit encore l'évolutivité de Redis. En stockant des éclats de données dans plusieurs instances Redis, les clusters Redis peuvent gérer des ensembles de données plus importants et des demandes simultanées plus élevées. La conception du cluster Redis permet à chaque n?ud de traiter les demandes indépendamment, améliorant la disponibilité et les performances du système.

 // redis Copy Exemple void réplicationfeedslaves (list * esclaves, int dictid, robj ** argv, int argc) {
    listNode * ln;
    listter li;
    Esclave de la divulgation *;
    int J, start, fin;

    Listrewind (esclaves, & li);
    while ((ln = listNext (& li))) {
        esclave = ln-> valeur;
        if (slave-> repstate == redis_repl_wait_bgsave_start) continue;

        / * Envoyez la signalisation multi-commandes au début de la transaction. * /
        if (slave-> Flags & redis_pre_psync) {
            addReplyMultibulklen (esclave, argc);
            pour (j = 0; j <argc; j) {
                AddReplyBulk (esclave, argv [j]);
            }
        } autre {
            start = (esclave-> drapeaux & redis_pre_psync)? 0: 1;
            end = (Slave-> Flags & redis_pre_psync)? Argc: Argc-1;
            AddReplyMultibulklen (esclave, démarrage final);
            pour (j = start; j <end; j) {
                AddReplyBulk (esclave, argv [j]);
            }
        }
    }
}

L'application pratique de redis

Redis propose un large éventail de scénarios d'application dans les projets réels. Voici quelques utilisations courantes:

cache

L'une des utilisations les plus courantes de Redis est une couche de cache. En stockant des données sur hotspot dans Redis, la vitesse de réponse de votre application peut être considérablement améliorée. La stratégie d'élimination du LRU et le mécanisme d'expiration de Redis le rendent très adapté à la mise en cache.

 # Exemple d'utilisation de redis comme import de cache redis

# Connexion à Redis Server R = redis.redis (host = 'localhost', port = 6379, db = 0)

# Set Cache R.Set ('User: 1', 'John Doe')

# Get cache user = r.get ('utilisateur: 1')
print (user.decode ('utf-8')) # sortie: John Doe

Stockage de session

Redis peut être utilisé pour stocker les données de session utilisateur, en particulier dans les systèmes distribués. En stockant les données de session dans Redis, le partage croisé des séances peut être réalisé, améliorant l'évolutivité du système.

 # Exemple d'utilisation de redis pour stocker l'importation de données de session redis
Importer JSON

# Connexion à Redis Server R = redis.redis (host = 'localhost', port = 6379, db = 0)

# SET Session Data Session_data = {'user_id': 1, 'username': 'John Doe'}
R.Set ('Session: 12345', json.dumps (session_data))

# Get Session Data Session = R.Get ('Session: 12345')
Si session:
    session_data = json.loads (session.decode ('utf-8'))
    print (session_data) # output: {'user_id': 1, 'username': 'John Doe'}

File d'attente de messages

La structure de données de la liste de Redis peut être utilisée pour implémenter des files d'attente de messages simples. Le modèle producteur et consommateur peut être implémenté via des commandes LPUSH et RPOP.

 # Exemple d'utilisation de redis pour implémenter la file d'attente de messages Import Redis

# Connexion à Redis Server R = redis.redis (host = 'localhost', port = 6379, db = 0)

# Producteur R.Lpush (?file d'attente?, ?message1?)
R.LPUSH (?Fitre?, ?message2?)

# Consumer Message = R.Rpop (?Fitre?)
print (message.decode ('utf-8')) # sortie: message2

Optimisation des performances et meilleures pratiques

Il existe des optimisations de performances et des meilleures pratiques à noter lors de l'utilisation de redis:

Sélectionnez la bonne structure de données

Redis fournit une variété de structures de données, chacune ayant ses scénarios applicables. Le choix de la bonne structure de données peut considérablement améliorer les performances de Redis. Par exemple, utilisez des ensembles commandés pour implémenter le classement, utiliser des tables de hachage pour stocker des objets, etc.

 # Exemple de classement à l'aide de collections ordonnées Importer Redis

# Connexion à Redis Server R = redis.redis (host = 'localhost', port = 6379, db = 0)

# Ajouter un score utilisateur r.zadd ('cadavre', {'user1': 100, 'user2': 200, 'user3': 150})

# Obtenez les trois premiers de la liste de classement TOPD_THREE = R.ZRevRange ('LAVERDBOW', 0, 2, WithScores = true)
Pour l'utilisateur, note dans top_ trois:
    print (f '{user.decode ("utf-8")}: {score}')

Pipelines et transactions

Les capacités de pipeline et de transaction de Redis peuvent améliorer les performances des opérations par lots. Pipeline permet aux clients d'emballer plusieurs commandes pour redis, réduisant les frais généraux du réseau. Les transactions garantissent l'atomicité d'un ensemble de commandes.

 # Exemple d'utilisation de Redis Pipeline Import Redis

# Connexion à Redis Server R = redis.redis (host = 'localhost', port = 6379, db = 0)

# Utiliser Pipe = R.Pipeline ()
Pipe.set ('key1', 'value1')
Pipe.set ('key2', 'value2')
pipe.execute ()

Surveillance et réglage

Utilisez les outils de surveillance de Redis, tels que Redis Insight ou la commande Monitor de Redis CLI, vous pouvez surveiller l'état de course de Redis en temps réel. En analysant les journaux de requête lents et l'utilisation de la mémoire, les goulots d'étranglement des performances peuvent être trouvés et réglés.

 # Moniteur redis en utilisant la commande monitor de redis CLI
Moniteur redis-CLI

Résumer

La conception architecturale de Redis et les divers scénarios d'application le rendent indispensable dans le développement d'applications modernes. En comprenant profondément les concepts principaux de Redis tels que le modèle unique, le multiplexage des E / S, le mécanisme de persistance, la réplication et le regroupement, vous pouvez mieux utiliser Redis pour améliorer les performances et l'évolutivité de votre application.

Dans les applications pratiques, le choix de la bonne structure de données, l'utilisation de pipelines et de transactions, ainsi que la surveillance et le réglage sont les clés pour améliorer les performances redis. J'espère que cet article peut vous aider à mieux comprendre et appliquer Redis, et je vous souhaite un voyage fluide sur Redis!

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!