Implémentation de verrous distribués à l'aide du framework Web Gin-gonic de Golang

Les verrous distribués sont un moyen courant de résoudre le problème de l'accès simultané aux ressources partagées. Dans un système distribué, étant donné que plusieurs nœuds exploitent la même ressource en même temps, une incohérence des données et une concurrence entre les ressources peuvent survenir. Par conséquent, l’utilisation d’un mécanisme de verrouillage distribué peut efficacement éviter ces problèmes. Dans Golang, vous pouvez utiliser le framework Gin-gonic pour implémenter des verrous distribués.

Gin-gonic est un framework Web léger basé sur un routeur HTTP et fournit de nombreux middleware puissants. Parmi eux, le middleware Mutex fourni par Gin-gonic peut être utilisé pour implémenter des verrous distribués. Le middleware Mutex nous permet de synchroniser entre différentes requêtes pour garantir qu'une seule requête puisse accéder aux ressources partagées en même temps.

Ci-dessous, nous utiliserons un exemple simple pour démontrer comment utiliser le framework Gin-gonic pour implémenter des verrous distribués.

Tout d'abord, nous devons installer les bibliothèques associées de gin et redis :

go get github.com/gin-gonic/gin
go get github.com/go-redis/redis

Ensuite, nous allons créer un service HTTP qui fournit deux API : verrouiller et déverrouiller. L'interface de verrouillage est utilisée pour obtenir des verrous distribués et l'interface de déverrouillage est utilisée pour libérer les verrous distribués. Nous pouvons utiliser Redis comme méthode de stockage pour les verrous distribués.

package main

import (
    "github.com/gin-gonic/gin"
    "github.com/go-redis/redis"
    "net/http"
    "time"
)

func main() {
    r := gin.Default()

    // 初始化Redis
    client := redis.NewClient(&redis.Options{
        Addr:     "localhost:6379",
        Password: "",
        DB:       0,
    })

    // lock接口
    r.POST("/lock", func(c *gin.Context) {
        lockKey := c.PostForm("key")
        locked, err := client.SetNX(lockKey, "locked", time.Second*30).Result()
        if err != nil || !locked {
            c.JSON(http.StatusConflict, gin.H{
                "code":    1,
                "message": "get lock failed",
            })
            return
        }
        c.JSON(http.StatusOK, gin.H{
            "code":    0,
            "message": "get lock success",
        })
    })

    // unlock接口
    r.POST("/unlock", func(c *gin.Context) {
        lockKey := c.PostForm("key")
        if err := client.Del(lockKey).Err(); err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{
                "code":    2,
                "message": "release lock failed",
            })
            return
        }
        c.JSON(http.StatusOK, gin.H{
            "code":    0,
            "message": "release lock success",
        })
    })

    r.Run()
}

Dans le code ci-dessus, nous initialisons d'abord un client Redis. Dans l'interface de verrouillage, nous utilisons la commande Redis SetNX pour définir la clé sur « verrouillée » lorsque la clé n'existe pas et définir un délai d'attente de 30 secondes. Si le verrou est acquis avec succès, 200 OK est renvoyé, sinon 409 Conflict est renvoyé. Dans l'interface de déverrouillage, nous utilisons la commande Redis Del pour libérer le verrou. Si le verrou est libéré avec succès, 200 OK est renvoyé, sinon 500 Erreur interne du serveur est renvoyé.

Maintenant, nous pouvons tester ces deux API à l'aide de la commande curl. Supposons que notre application s'exécute sur localhost:8080:

# 获取锁
curl --request POST 
  --url http://localhost:8080/lock 
  --header 'content-type: application/x-www-form-urlencoded' 
  --data key=mylock
# {"code":0,"message":"get lock success"}

# 再次获取锁
curl --request POST 
  --url http://localhost:8080/lock 
  --header 'content-type: application/x-www-form-urlencoded' 
  --data key=mylock
# {"code":1,"message":"get lock failed"}

# 释放锁
curl --request POST 
  --url http://localhost:8080/unlock 
  --header 'content-type: application/x-www-form-urlencoded' 
  --data key=mylock
# {"code":0,"message":"release lock success"}

Grâce au test ci-dessus, nous pouvons voir que notre application Gin-gonic a implémenté avec succès les verrous distribués. Grâce au middleware Mutex, nous pouvons facilement mettre en œuvre des verrous distribués pour garantir un accès simultané sécurisé aux ressources partagées.

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!