SET lock_key unique_value NX PX 30000

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"
    "time"

    "github.com/go-redis/redis/v8"
)

// 初始化Redis客戶端
func InitRedisClient() *redis.Client {
    rdb := redis.NewClient(&redis.Options{
        Addr:     "localhost:6379", // Redis服務(wù)器地址
        Password: "",               // 密碼，沒有則為空
        DB:       0,                // 使用默認(rèn)DB
    })
    
    // 通過Ping命令測試連接
    ctx := context.Background()
    _, err := rdb.Ping(ctx).Result()
    if err != nil {
        log.Fatalf("無法連接到Redis: %v", err)
    }
    fmt.Println("Redis連接成功")
    return rdb
}

// 獲取數(shù)據(jù)（緩存優(yōu)先）
func GetData(rdb *redis.Client, key string) (string, error) {
    ctx := context.Background()
    
    // 1. 首先嘗試從緩存獲取
    val, err := rdb.Get(ctx, key).Result()
    if err == nil {
        fmt.Println("緩存命中")
        return val, nil // 成功命中，直接返回
    }
    if err != redis.Nil {
        return "", err // 出現(xiàn)其他錯誤
    }
    
    // 2. 緩存未命中，從數(shù)據(jù)源（如數(shù)據(jù)庫）獲取
    fmt.Println("緩存未命中，從數(shù)據(jù)源獲取")
    data, err := GetDataFromSource(key)
    if err != nil {
        return "", err
    }
    
    // 3. 將數(shù)據(jù)存入緩存，并設(shè)置過期時間（例如5分鐘）
    err = rdb.Set(ctx, key, data, 5*time.Minute).Err()
    if err != nil {
        // 此處通常記錄日志，而不是直接返回錯誤，因為數(shù)據(jù)庫查詢已經(jīng)成功
        log.Printf("警告：數(shù)據(jù)寫入緩存失敗: %v", err)
    }
    return data, nil
}

// 模擬從數(shù)據(jù)庫等數(shù)據(jù)源獲取數(shù)據(jù)
func GetDataFromSource(key string) (string, error) {
    // 這里模擬一個耗時的數(shù)據(jù)庫查詢
    time.Sleep(100 * time.Millisecond)
    result := map[string]string{"id": key, "name": "示例數(shù)據(jù)"}
    jsonData, _ := json.Marshal(result)
    return string(jsonData), nil
}

func main() {
    rdb := InitRedisClient()
    defer rdb.Close() // 確保程序退出前關(guān)閉連接

    data, err := GetData(rdb, "user:1001")
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("獲取到的數(shù)據(jù): %s\n", data)
}

package main

import (
    "context"
    "crypto/rand"
    "encoding/base64"
    "fmt"
    "log"
    "time"

    "github.com/go-redis/redis/v8"
)

// 用于原子釋放鎖的Lua腳本
// 先比較鎖的值是否與當(dāng)前客戶端匹配，匹配才刪除
var unlockScript = redis.NewScript(`
if redis.call("get", KEYS[1]) == ARGV[1] then
    return redis.call("del", KEYS[1])
else
    return 0
end
`)

type RedisLock struct {
    client *redis.Client
    ctx    context.Context
}

func NewRedisLock(client *redis.Client) *RedisLock {
    return &RedisLock{
        client: client,
        ctx:    context.Background(),
    }
}

// Lock 嘗試獲取分布式鎖
func (rl *RedisLock) Lock(lockKey string, expireTime time.Duration) (bool, string, error) {
    // 生成一個唯一的隨機值作為鎖的value，用于標(biāo)識當(dāng)前客戶端
    token, err := generateRandomToken()
    if err != nil {
        return false, "", err
    }

    // 使用SetNX命令，只有key不存在時才能設(shè)置成功，并設(shè)置過期時間
    isSet, err := rl.client.SetNX(rl.ctx, lockKey, token, expireTime).Result()
    if err != nil {
        return false, "", err
    }
    return isSet, token, nil
}

// Unlock 安全地釋放分布式鎖
func (rl *RedisLock) Unlock(lockKey string, token string) error {
    // 執(zhí)行Lua腳本，確保判斷鎖歸屬和刪除鎖是原子操作
    result, err := unlockScript.Run(rl.ctx, rl.client, []string{lockKey}, token).Int()
    if err != nil {
        return err
    }
    if result == 1 {
        fmt.Println("鎖釋放成功")
    } else {
        fmt.Println("鎖釋放失?。嚎赡懿皇擎i的持有者或鎖已過期")
    }
    return nil
}

// 生成隨機token
func generateRandomToken() (string, error) {
    b := make([]byte, 16)
    _, err := rand.Read(b)
    if err != nil {
        return "", err
    }
    return base64.StdEncoding.EncodeToString(b), nil
}

func main() {
    rdb := redis.NewClient(&redis.Options{
        Addr: "localhost:6379",
    })
    defer rdb.Close()

    lock := NewRedisLock(rdb)
    lockKey := "my_distributed_lock"
    expireTime := 10 * time.Second

    // 嘗試加鎖
    acquired, token, err := lock.Lock(lockKey, expireTime)
    if err != nil {
        log.Fatal(err)
    }
    if acquired {
        fmt.Println("成功獲取分布式鎖")
        
        // 模擬在鎖保護(hù)下執(zhí)行關(guān)鍵業(yè)務(wù)邏輯
        fmt.Println("正在執(zhí)行關(guān)鍵業(yè)務(wù)邏輯...")
        time.Sleep(5 * time.Second)
        fmt.Println("關(guān)鍵業(yè)務(wù)邏輯執(zhí)行完畢")

        // 業(yè)務(wù)完成，釋放鎖
        err = lock.Unlock(lockKey, token)
        if err != nil {
            log.Fatal(err)
        }
    } else {
        fmt.Println("獲取分布式鎖失敗，可能有其他客戶端正持有鎖")
    }
}

package main

import (
    "context"
    "fmt"
    "time"

    "github.com/go-redis/redis/v8"
)

func main() {
    rdb := redis.NewClient(&redis.Options{
        Addr: "localhost:6379",
    })
    ctx := context.Background()

    for i := 1; i <= 5; i++ {
        message := fmt.Sprintf("這是第 %d 條消息", i)
        // 向 "news" 頻道發(fā)布消息
        err := rdb.Publish(ctx, "news", message).Err()
        if err != nil {
            panic(err)
        }
        fmt.Printf("發(fā)布消息: %s\n", message)
        time.Sleep(1 * time.Second)
    }
}

package main

import (
    "context"
    "fmt"
    "log"

    "github.com/go-redis/redis/v8"
)

func main() {
    rdb := redis.NewClient(&redis.Options{
        Addr: "localhost:6379",
    })
    ctx := context.Background()

    // 訂閱 "news" 頻道
    pubsub := rdb.Subscribe(ctx, "news")
    defer pubsub.Close()

    // 從頻道接收消息
    ch := pubsub.Channel()
    for msg := range ch {
        fmt.Printf("收到來自頻道 %s 的消息: %s\n", msg.Channel, msg.Payload)
    }
}

package main

import (
    "context"
    "encoding/json"
    "fmt"

    "github.com/go-redis/redis/v8"
)

type Message struct {
    ID      string `json:"id"`
    Content string `json:"content"`
}

func main() {
    rdb := redis.NewClient(&redis.Options{
        Addr: "localhost:6379",
    })
    ctx := context.Background()
    queueName := "my_task_queue"

    message := Message{ID: "1", Content: "需要處理的任務(wù)內(nèi)容"}
    jsonMsg, _ := json.Marshal(message)

    // 將消息放入隊列右側(cè) (尾部)
    err := rdb.LPush(ctx, queueName, jsonMsg).Err()
    if err != nil {
        panic(err)
    }
    fmt.Println("消息已生產(chǎn):", string(jsonMsg))
}

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"

    "github.com/go-redis/redis/v8"
)

func main() {
    rdb := redis.NewClient(&redis.Options{
        Addr: "localhost:6379",
    })
    ctx := context.Background()
    queueName := "my_task_queue"

    for {
        // 從隊列左側(cè) (頭部) 阻塞地獲取消息，超時時間設(shè)為0（無限等待）
        result, err := rdb.BRPop(ctx, 0, queueName).Result() // result[0]是隊列名，result[1]是消息體
        if err != nil {
            log.Fatal(err)
        }

        var msg Message
        err = json.Unmarshal([]byte(result[1]), &msg)
        if err != nil {
            log.Printf("消息解析失敗: %v", err)
            continue
        }
        fmt.Printf("開始處理消息: ID=%s, Content=%s\n", msg.ID, msg.Content)
        // ... 這里處理業(yè)務(wù)邏輯 ...
        fmt.Printf("消息 %s 處理完畢\n", msg.ID)
    }
}