Introduction simple à l'application du verrouillage Redis

En fait, il n'est pas approprié de modifier les données avec plusieurs threads. Après tout, le serveur Redis est monothread et toutes les commandes sont exécutées en série uniquement lorsque le client envoie. commandes en même temps que cela provoque la sérialisation. Certains problèmes d'arrangement des commandes et les différences d'heure du réseau entraînent une incohérence des données. Bien que cet article concerne l'addition et la soustraction de nombres, afin d'illustrer la situation de verrouillage, la commande atomique incr n'est pas utilisée intentionnellement. (Recommandé : tutoriel vidéo Redis)

Tout d'abord, ajoutez un simple RedisHelper, une valeur définie, une valeur d'obtention et un verrou de concurrence défini, afin que dans mes opérations ultérieures, vous puissiez savoir exactement ce que j'ai fait.

public class RedisHelper
    {
        public RedisClient client = new RedisClient("127.0.0.1", 6379);
        public void Set<T>(string key, T val)
        {
            client.Set(key, val);
        }
        public T Get<T>(string key)
        {
            var result = client.Get<T>(key);
            return result;
        }
        public IDisposable Acquire(string key)
        {
           return  client.AcquireLock(key);
        }
    }

En regardant le code concurrent ci-dessous, je n'ai créé que deux nouveaux Threads. Deux threads veulent accéder à la même clé en même temps, chacun accédant 50 000 fois dans des conditions simultanées, il nous est difficile de garantir l'exactitude des données.

static void Main(string[] args)
        {
            RedisHelper rds = new RedisHelper();
            rds.Set<int>("mykey1", 0);
            Thread myThread1 = new Thread(AddVal);
            Thread myThread2 = new Thread(AddVal);
            myThread1.Start();
            myThread2.Start();
            Console.WriteLine("等待两个线程结束");
            Console.ReadKey();
        }

        public static void AddVal()
        {
            RedisHelper rds = new RedisHelper();
            for (int i = 0; i < 50000; i++)
            {
                
                    int result = rds.Get<int>("mykey1");
                    rds.Set<int>("mykey1", result + 1);
                
            }
            Console.WriteLine("线程结束，输出" + rds.Get<int>("mykey1"));
        }

Oui, avec notre seul thread, exécuter deux 50 000 produira 100 000. Désormais, deux threads simultanés s'exécutent en même temps. En raison de la concurrence, les résultats des données ne sont souvent pas ceux que nous souhaitons. Alors comment résoudre ce problème, Redis est déjà prêt pour nous !

Vous pouvez voir qu'une méthode dans mon RedisHelper est publique IDisposable Acquire (clé de chaîne). Vous pouvez également voir qu'il renvoie IDisposable, ce qui prouve que nous devons libérer manuellement les ressources.

L'AcquireLock à l'intérieur de la méthode est le point clé. C'est comme demander un verrou dans Redis. La ressource verrouillée n'est accessible que par un seul thread et ne sera pas obtenue ou définie par deux threads en même temps. Ces deux threads doivent être effectués en alternance. Bien entendu, l'alternance ici ne signifie pas une fois pour vous et une fois pour moi. Cela peut aussi être pour vous plusieurs fois et une fois pour moi.

static void Main(string[] args)
        {
            RedisHelper rds = new RedisHelper();
            rds.Set<int>("mykey1", 0);
            Thread myThread1 = new Thread(AddVal);
            Thread myThread2 = new Thread(AddVal);
            myThread1.Start();
            myThread2.Start();
            Console.WriteLine("等待两个线程结束");
            Console.ReadKey();
        }

        public static void AddVal()
        {
            RedisHelper rds = new RedisHelper();
            for (int i = 0; i < 50000; i++)
            {
                using (rds.Acquire("lock"))
                {
                    int result = rds.Get<int>("mykey1");
                    rds.Set<int>("mykey1", result + 1);
                }
            }
            Console.WriteLine("线程结束，输出" + rds.Get<int>("mykey1"));
        }

Vous pouvez voir que j'avais l'habitude d'appeler ma méthode Acquire pour acquérir le verrou.

Le résultat final est de 100 000, ce qui est le résultat correct que nous souhaitons. Le 8W+ précédent est dû au fait que l'un des deux threads a terminé l'exécution en premier.

De plus, lors du processus d'utilisation officiel, il est recommandé de supprimer le verrou qui nous a été remis après utilisation, et d'ajouter un délai d'expiration, en utilisant expire.

Pour éviter une sortie inattendue pendant l'exécution du programme, le verrou existera toujours et les données verrouillées pourraient ne pas être mises à jour ou obtenues à l'avenir.

Vous pouvez également essayer de ne pas définir l'expiration. Lorsque le programme commence tout juste à s'exécuter, fermez la console, réexécutez le programme et obtenez la valeur que vous avez verrouillée dans la console d'opération redis-cli, et ce sera le cas. obtenu pour toujours. Moins que.

Toutes les machines connectées à cette instance Redis ne peuvent avoir qu'un seul verrou qui acquiert le nom spécifié en même temps

Voici comment StackExchange.Redis est écrit

var info = "name-"+Environment.MachineName;
            //如果5秒不释放锁 自动释放。避免死锁
            if (db.LockTake("name", info, TimeSpan.FromSeconds(5)))
            {
                try
                {
                   
                }
                catch (Exception ex)
                {
                    
                }
                finally
                {
                   
                    db.LockRelease("name", token);
                }
            }

. Plus de redis Pour plus de connaissances, veuillez faire attention à la colonne Tutoriel de base de données 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!