使用 Go 语言与 Redis 构建高效缓存与消息队列系统

于 2024-10-10 18:27:17 发布
阅读量395 收藏 3
点赞数 5
文章标签： 缓存 golang redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34820371/article/details/142829018
版权

什么是 Redis？

  • Redis 是一个开源的内存数据库，支持多种数据结构，包括字符串、列表、集合、哈希和有序集合。由于 Redis 运行在内存中，读写速度极快，常被用于构建缓存系统、实时排行榜、会话存储和消息队列等高并发场景下的服务。
  • 在这篇博客中，我们将介绍如何使用 Go 语言集成 Redis，构建高效的缓存和消息队列系统。

安装 Redis

  • 安装 Redis： 你可以通过以下命令安装 Redis（适用于 Linux 和 macOS）：
sudo apt-get install redis-server
  • 或者通过 Homebrew 安装：
brew install redis

启动 Redis 服务

redis-server

验证安装

  • 可以通过以下命令进入 Redis CLI，验证 Redis 是否正常运行
redis-cli

安装 Go Redis 客户端

  • 在 Go 项目中，我们将使用 go-redis/redis 这个流行的 Redis 客户端库。你可以通过以下命令安装：
go get github.com/go-redis/redis/v8

连接 redis

rdb := redis.NewClient(&redis.Options{
	Addr:     "localhost:6379",
	Password: "",
	DB:       0,
})

string 类型

  1. set 设置 string 的值
func TestSetKey(t *testing.T) {
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})
	err := rdb.Set(ctx, "name", "hello world", time.Second*1000).Err()
	if err != nil {
		panic(err)
	}
	fmt.Println("设置值成功")
}
  1. get 获取 string 的值
func TestGetKey(t *testing.T) {
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})
	result, err := rdb.Get(ctx, "name").Result()
	if err != nil {
		panic(err)
	}
	fmt.Println("result", result)
}
  1. getset 获取到的值是上一次的值
func TestGetSet(t *testing.T) {
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})
	result, err := rdb.GetSet(ctx, "name", "hello world").Result()
	if err != nil {
		panic(err)
	}
	fmt.Println(result)
}
  1. setnx 如果值存在则不设置，如果不存在则设置
func TestSetNx(t *testing.T) {
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})
	err := rdb.SetNX(ctx, "name", "hello set nex", time.Second*1000).Err()
	if err != nil {
		panic(err)
	}

}
  1. mget 批量获取值
func TestMGet(t *testing.T) {
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})
	result, err := rdb.MGet(ctx, "name", "k1", "k2").Result()
	if err != nil {
		panic(err)
	}
	fmt.Println(result)
}
  1. 批量设置
func TestMSet(t *testing.T) {
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})
	err := rdb.MSet(ctx, "k1", "value1", "k2", "value2", "k3", "value3").Err()
	if err != nil {
		panic(err)
	}

}
  1. 自增
// 自增
func TestIncrBy(t *testing.T) {
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})
	result, err := rdb.IncrBy(ctx, "money", 1).Result()
	if err != nil {
		panic(err)
	}
	fmt.Println(result)
}
  1. 自减
func TestDecrBy(t *testing.T) {
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})
	val, err := rdb.DecrBy(ctx, "money", 1).Result()
	if err != nil {
		panic(err)
	}
	fmt.Println(val)
}
  1. 删除
func TestDel(t *testing.T) {
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})
	err := rdb.Del(ctx, "k1").Err()
	if err != nil {
		panic(err)
	}
}
  1. 设置过期时间
func TestExpire(t *testing.T) {
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})
	rdb.Expire(ctx, "key2", 1000*time.Second)
}

哈希类型

  1. HSet 设置哈希值
func TestHSet(t *testing.T) {
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})
	result, err := rdb.Ping(ctx).Result()
	if err != nil {
		panic(err)
	}
	t.Log(result)
	err = rdb.HSet(ctx, "user", "name", "张德志").Err()
	if err != nil {
		panic(err)
	}
	t.Log("设置hash成功")
}
  1. HGet 获取哈希值
func TestHGet(t *testing.T) {
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})
	_, err := rdb.Ping(ctx).Result()
	if err != nil {
		panic(err)
	}
	t.Logf("连接数据库成功")
	result, err1 := rdb.HGet(ctx, "user", "name").Result()
	if err1 != nil {
		panic(err1)
	}
	t.Logf("获取值:%s", result)
}
  1. TestHGetAll 获取所有哈希值
func TestHGetAll(t *testing.T) {
	var err error
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr: "127.0.0.1:6379",
		DB:   0,
	})
	_, err = rdb.Ping(ctx).Result()
	if err != nil {
		panic(err)
	}
	t.Log("连接数据库成功")
	result, err1 := rdb.HGetAll(ctx, "user").Result()
	if err1 != nil {
		panic(err1)
	}
	t.Log(result)
}
  1. HIncrBy 哈希累加
func TestHIncrBy(t *testing.T) {
	var err error
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})
	_, err = rdb.Ping(ctx).Result()
	if err != nil {
		panic(err)
	}
	t.Log("数据库连接成功")
	count, err1 := rdb.HIncrBy(ctx, "user", "count", 2).Result()
	if err1 != nil {
		panic(err1)
	}
	t.Log(count)
}
  1. HKeys 获取所有 keys
func TestHKeys(t *testing.T) {
	var err error
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})
	_, err = rdb.Ping(ctx).Result()
	if err != nil {
		panic(err)
	}
	t.Log("连接数据库成功")
	keys, err1 := rdb.HKeys(ctx, "user").Result()
	if err1 != nil {
		panic(err)
	}
	t.Log(keys)
}
  1. HLen 查询字段数量
func TestHLen(t *testing.T) {
	var err error
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})
	_, err = rdb.Ping(ctx).Result()
	if err != nil {
		panic(err)
	}
	t.Log("连接数据库成功")
	result, err1 := rdb.HLen(ctx, "user").Result()
	if err1 != nil {
		panic(err1)
	}
	t.Log(result)

}
  1. HMGet 批量获取
func TestMGet(t *testing.T) {
	var err error
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})
	_, err = rdb.Ping(ctx).Result()
	if err != nil {
		panic(err)
	}
	result, err1 := rdb.HMGet(ctx, "user", "name", "count").Result()
	if err1 != nil {
		panic(err)
	}
	t.Log(result)
}
  1. HMSet 批量设置
func TestHMSet(t *testing.T) {
	var err error
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})
	_, err = rdb.Ping(ctx).Result()
	if err != nil {
		panic(err)
	}
	data := make(map[string]interface{})
	data["name"] = "周华建"
	data["age"] = 44
	data["gender"] = "男"

	err = rdb.HMSet(ctx, "user", data).Err()
	if err != nil {
		panic(err)
	}
}
  1. HDel 删除值
func TestHDel(t *testing.T) {
	var err error
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})
	_, err = rdb.Ping(ctx).Result()
	if err != nil {
		panic(err)
	}
	err = rdb.HDel(ctx, "user", "name").Err()
	if err != nil {
		panic(err)
	}

}
  1. 检测是否存在
func TestHExists(t *testing.T) {
	var err error
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr: "127.0.0.1:6379",
		DB:   0,
	})
	_, err = rdb.Ping(ctx).Result()
	if err != nil {
		panic(err)
	}
	result, err1 := rdb.HExists(ctx, "user", "name").Result()
	if err1 != nil {
		panic(err1)
	}
	t.Log(result)
}

List 类型

  1. TestLPush 左侧插入
func TestLPush(t *testing.T) {
	var err error
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})
	_, err = rdb.Ping(ctx).Result()
	if err != nil {
		panic(err)
	}

	err = rdb.LPush(ctx, "key", 1, 2, 3, 4, 5).Err()
	if err != nil {
		panic(err)
	}
	t.Log("插入成功")
}
  1. 判断集合左侧是否可以插入，如果存在则不插入，如果不存在则插入
func TestLPushX(t *testing.T) {
	var err error
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})
	_, err = rdb.Ping(ctx).Result()
	if err != nil {
		panic(err)
	}
	err = rdb.LPushX(ctx, "key", 6, 7, 8).Err()
	if err != nil {
		panic(err)
	}
}
  1. 从右则删除一个值并返回删除后的值
func TestRPop(t *testing.T) {
	var err error
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})
	_, err = rdb.Ping(ctx).Result()
	if err != nil {
		panic(err)
	}
	val, err1 := rdb.RPop(ctx, "key").Result()
	if err1 != nil {
		panic(err1)
	}
	t.Log(val)
}
  1. RPush 从列表右则插入值
func TestRPush(t *testing.T) {
	var err error
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})
	_, err = rdb.Ping(ctx).Result()
	if err != nil {
		panic(err)
	}
	err = rdb.RPush(ctx, "key", 12).Err()
	if err != nil {
		panic(err)
	}
}
  1. LPop 从左侧删除
func TestLPop(t *testing.T) {
	var err error
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})
	_, err = rdb.Ping(ctx).Result()
	if err != nil {
		panic(err)
	}
	result, err1 := rdb.LPop(ctx, "key").Result()
	if err1 != nil {
		panic(err1)
	}
	fmt.Println(result)
}
  1. LLen 获取集合的长度
func TestLLen(t *testing.T) {
	var err error
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})
	_, err = rdb.Ping(ctx).Result()
	if err != nil {
		panic(err)
	}
	result, err1 := rdb.LLen(ctx, "key").Result()
	if err1 != nil {
		panic(err1)
	}
	t.Log(result)
}
  1. 遍历集合
func TestLRange(t *testing.T) {
	var err error
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})
	_, err = rdb.Ping(ctx).Result()
	if err != nil {
		panic(err)
	}
	result, err1 := rdb.LRange(ctx, "key", 0, -1).Result()
	if err1 != nil {
		panic(err1)
	}
	t.Log(result)

}
  1. 删除数据
func TestLRem(t *testing.T) {
	var err error
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})
	_, err = rdb.Ping(ctx).Result()
	if err != nil {
		panic(err)
	}
	t.Log("数据库连接成功")
	err = rdb.LRem(ctx, "key", 0, -1).Err()
	if err != nil {
		panic(err)
	}
	t.Log("删除成功")

}
  1. 获取值的索引
func TestLIndex(t *testing.T) {
	var err error
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr: "127.0.0.1:6379",
		DB:   0,
	})
	_, err = rdb.Ping(ctx).Result()
	if err != nil {
		panic(err)
	}

	val, err := rdb.LIndex(ctx, "key", 1).Result()
	if err != nil {
		panic(err)
	}
	t.Log(val)
}

set 集合

  1. sadd 添中集合
func TestSAdd(t *testing.T) {
	var err error
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})
	_, err = rdb.Ping(ctx).Result()
	if err != nil {
		panic(err)
	}
	err = rdb.SAdd(ctx, "set", 100).Err()
	if err != nil {
		panic(err)
	}
	t.Log("添加集合成功")
}
  1. scard 获取集合元素个数
func TestSCard(t *testing.T) {
	var err error
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr: "127.0.0.1:6379",
		DB:   0,
	})
	_, err = rdb.Ping(ctx).Result()
	if err != nil {
		panic(err)
	}
	t.Log("连接数据库成功")
	size, err := rdb.SCard(ctx, "set").Result()
	if err != nil {
		panic(err)
	}
	t.Log(size)
}

3.sIsmember 判断元素是否在集合中

func TestSIsMember(t *testing.T) {
	var err error
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})
	_, err = rdb.Ping(ctx).Result()
	if err != nil {
		panic(err)
	}
	ok, _ := rdb.SIsMember(ctx, "key", 100).Result()
	if !ok {
		t.Log("集合不含令指定元素")
		return
	}
	t.Log("集合包含指定元素")
}
  1. smembers 获取集合中所有的元素
func TestSMembers(t *testing.T) {

	var err error
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})
	_, err = rdb.Ping(ctx).Result()
	if err != nil {
		panic(err)
	}
	values, err1 := rdb.SMembers(ctx, "set").Result()
	if err1 != nil {
		panic(err1)
	}
	t.Log(values)
}
  1. srem 删除集合中元素
func TestSRem(t *testing.T) {
	var err error
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})
	_, err = rdb.Ping(ctx).Result()
	if err != nil {
		panic(err)
	}
	err = rdb.SRem(ctx, "set", 100).Err()
	if err != nil {
		panic(err)
	}
	t.Log("删除成功")
}
  1. SPop 随机删除并返回删除的值
func TestSPop(t *testing.T) {
	var err error
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})
	_, err = rdb.Ping(ctx).Result()
	if err != nil {
		panic(err)
	}
	val, _ := rdb.SPop(ctx, "set").Result()
	t.Log(val)
	vals, _ := rdb.SPopN(ctx, "set", 5).Result()
	t.Log(vals)
}

可排序集合

  1. zadd 添加一个或多个元素到集合，如果元素已经存在则更新分数
func TestZAdd(t *testing.T) {
	var err error
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr: "localhost:6379",
		DB:   0,
	})
	_, err = rdb.Ping(ctx).Result()
	if err != nil {
		panic(err)
	}
	err = rdb.ZAdd(ctx, "zAdd", redis.Z{Score: 2.5, Member: "张德志"}).Err()
	if err != nil {
		panic(err)
	}
	t.Log("插入成功")
}
  1. zcard 返回集合元素个数
func TestZCard(t *testing.T) {
	var err error
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})
	_, err = rdb.Ping(ctx).Result()
	if err != nil {
		panic(err)
	}
	size, err1 := rdb.ZCard(ctx, "zAdd").Result()
	if err1 != nil {
		panic(err)
	}
	t.Log(size)

}
  1. zCount 获取某个区间的值
func TestZCount(t *testing.T) {
	var err error
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})
	_, err = rdb.Ping(ctx).Result()
	if err != nil {
		panic(err)
	}
	size, err1 := rdb.ZCount(ctx, "zAdd", "1", "5").Result()
	if err1 != nil {
		panic(err1)
	}
	t.Log(size)

}
  1. ZIncrBy 增加元素的分数
func TestZIncrBy(t *testing.T) {
	var err error
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})
	_, err = rdb.Ping(ctx).Result()
	if err != nil {
		panic(err)
	}
	err = rdb.ZIncrBy(ctx, "zAdd", 2, "张德志").Err()
	if err != nil {
		panic(err)
	}
}
  1. zrange 返回集合中某个索引范围的元素
func TestZRange(t *testing.T) {
	var err error
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})
	_, err = rdb.Ping(ctx).Result()
	if err != nil {
		panic(err)
	}
	result, err1 := rdb.ZRange(ctx, "zAdd", 0, -1).Result()
	if err1 != nil {
		panic(err1)
	}
	t.Log(result)

}
  1. ZRangeByScore 根据分数范围返回集合元素，元素根据分数从小到大排序，支持分页
func TestZRangeByScore(t *testing.T) {
	var err error
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})
	_, err = rdb.Ping(ctx).Result()
	if err != nil {
		panic(err)
	}
	opt := redis.ZRangeBy{
		Min:    "2",
		Max:    "1000",
		Offset: 0,
		Count:  5,
	}
	vals, err1 := rdb.ZRangeByScore(ctx, "set", &opt).Result()
	if err1 != nil {
		panic(err1)
	}
	t.Log(vals)
}
  1. 根据指定 key 删除元素
func TestZRem(t *testing.T) {
	var err error
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})
	_, err = rdb.Ping(ctx).Result()
	if err != nil {
		panic(err)
	}
	err = rdb.ZRem(ctx, "zAdd", "张德志").Err()
	if err != nil {
		panic(err)
	}
	t.Log("删除成功")
}
  1. ZRemRangeByRank 根据索引范围删除元素
func TestZRemRangeByRank(t *testing.T) {
	var err error
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})
	_, err = rdb.Ping(ctx).Result()
	if err != nil {
		panic(err)
	}
	err = rdb.ZRemRangeByRank(ctx, "zAdd", 0, 1).Err()
	if err != nil {
		panic(err)
	}
	t.Log("删除成功")
}
相关链接

演示地址
获取更多
源码地址

数擎科技
关注
Go必知必会系列：分布式缓存与Redis
AI天才研究院
09-24 2493
Redis（Remote Dictionary Server）是一个开源的使用ANSI C语言编写、支持网络、基于内存的数据结构存储系统。它可以用作数据库、缓存、消息中间件或按键-值对存储器。本文所涉及到的Redis知识点主要基于Redis 4.0版本，如果你还没有接触过Redis，可以参考一下这个网站https://redis.io/documentation。
go语言操作redis集群案例
09-26
在现代的分布式系统中，Redis作为一款高性能的键值存储数据库，经常被用作缓存、消息队列等场景。而Go语言以其简洁的语法和高效的性能，成为了编写分布式服务的首选语言。本篇文章将详细讲解如何使用Go语言操作Redis...
Redis 如何实现消息队列
hello_1566的博客
12-22 1400
消息队列（Messeage Queue，MQ）是在分布式系统架构中常用的一种中间件技术，从字面表述看，是一个存储消息的队列，所以它一般用于给 MQ 中间的两个组件提供通信服务。
基于Redis实现消息队列的实践
竹林幽深
01-21 316
2、定义三个延迟队列BeforeQueue、RunningQueue、CompleteQueue，对队列的任务进行存取，BeforeQueue用于对待执行状态的任务的存取，Running用于对执行中状态的任务的存取，CompleteQueue用于对执行完成状态的任务的存取，在三个任务队列中，取出元素是阻塞的，即如果队列中没有新的任务，当前线程会一直阻塞等待，直到有新的任务进入；因为它是有序集合，有序集合的存储元素值是不能重复的，但分值可以重复，也就是说当消息值重复时，只能存储一条信息在 ZSet 中。
Go语言的Redis与NoSQL
AI天才研究院
01-28 648
1.背景介绍 1. 背景介绍 Redis 和 NoSQL 是现代软件开发中不可或缺的技术。Redis 是一个高性能的键值存储系统，它提供了内存级别的数据存储和操作。NoSQL 是一种非关系型数据库系统，它可以存储和操作大量的不结构化数据。Go 语言是一种现代的编程语言，它具有高性能、易用性和跨平台性。 在本文中，我们将讨论 Go 语言如何与 Redis 和 NoSQL 系统进行集成和操作。我...
go-redis的简单使用
m0_66316879的博客
03-08 896
go-redis
消息队列介绍、RabbitMQ&Redis的重点介绍与简单应用
心核智慧科技 360度人脸识别开放算法 新零售系统定制
04-03 595
消息队列介绍、RabbitMQ、Redis 一、什么是消息队列 　　这个概念我们百度Google能查到一大堆文章，所以我就通俗的讲下消息队列的基本思路。 　　还记得原来写过Queue的文章，不管是线程queue还是进程queue他都是一种消息队列。他都是基于生产者消费者模型来处理消息。 　　Python中的进程queue，是用于父进程与子进程，或者同属于一个父进程下的多个子进程之间进...
Go语言的数据库操作：MySQL和Redis
AI天才研究院
01-25 668
1.背景介绍 1. 背景介绍 Go语言(Golang)是Google开发的一种静态类型、垃圾回收的编程语言。Go语言的设计目标是简单、高效、可扩展和易于使用。Go语言的标准库提供了对数据库操作的支持，包括MySQL和Redis等。 MySQL是一种关系型数据库管理系统，是最受欢迎的开源关系型数据库之一。Redis是一种高性能的键值存储系统，是NoSQL数据库的一种。Go语言的数据库操作可以通...
【Redis】构建强韧的远程Redis连接与端口保障机制完美指南
寸铁的博客
06-08 986
【Redis】构建强韧的远程Redis连接与端口保障机制完美指南 通过学习本文，读者可以掌握利用Golang编写出高效、稳健的远程Redis连接程序的方法，为应用提供可靠的数据支持!
Redis缓存更新和同步策略、缓存穿透、缓存击穿、缓存雪崩
qq_62767608的博客
12-04 3043
方法来表示获取锁，该方法含义是 redis 中如果没有这个key，则插入成功，返回1，在 stringRedisTemplate 中返回true， 如果有这个key则插入失败，则返回0，在stringRedisTemplate返回false，我们可以通过true，或者是false，来表示是否有线程成功插入key，成功插入的key的线程我们认为他就是获得到锁的线程。当代计算机最大的问题是 cpu性能提升了，但内存读写速度没有跟上，所以为了适应当下的情况，增加了cpu的L1，L2，L3级的缓存。
go语言学习 - 封装redis常用基本命令.zip
06-06
总的来说，这个学习资源将帮助我们深入理解Go语言与Redis的集成，提升我们在分布式系统和数据存储领域的技能。通过实践和学习这个教程，我们可以更好地利用Go的并发特性和Redis的高性能来构建高效的应用。
包括面试高频算法、系统设计、计算机网络、操作系统、C++、Java、golang、MySQL、Redis、K8s、消息队列等常见
05-01
这个压缩包文件涵盖了多个关键领域的知识，包括但不限于算法、系统设计、计算机网络、操作系统、编程语言（如C++、Java、Golang）以及数据库和分布式技术（如MySQL、Redis、Kubernetes，以及消息队列）。下面将对...
在Golang中使用Redis的方法示例
09-09
在Golang中使用Redis是一种常见的数据缓存和处理方式，特别是在高并发的场景下，Redis的优势尤为明显。本文将详细讲解如何在Golang环境中与Redis进行交互，以及Redis的主要数据结构和常见应用场景。 首先，Redis是...
Go语言访问redis
05-30
在IT行业中，Go语言（Golang）以其高效、简洁的语法和强大的并发处理能力而备受青睐，尤其是在构建网络服务和微服务时。Redis则是一种高性能的键值存储系统，常用于缓存、会话管理、消息队列等多种场景。本项目以"Go...
高性能缓存方案 —— Caffeine
最新发布
qq_35843514的博客
10-09 367
Caffeine是一个高性能的Java缓存库，它提供了本地缓存的功能。Caffeine和Redis都是内存级别的缓存，为什么要使用在这两缓存作为二级缓存，它们两有什么区别呢?虽然它们都是内存级别的缓存，但是Redis是需要单独部署的，其需要一个单独的进程，在tomcat访问Redis时需要网络通信的开销，而Caffeine跟我们项目代码是写在一起的，它是JVM级别的缓存，用的就是Java中的堆内存，无需网络的通信的开销，在Caffeine找不到数据后才会去redis中查找。
【d59】【Java】【力扣】146.LRU缓存
m0_74814985的博客
10-06 302
尾删是一种 特殊的 删除某个元素所以可以直接调用：删除某个元素。
猫猫cpu的缓存（NW）
Tonvia的博客
10-05 1284
在做 dp 的时候经常在某个细节处死扣，总的说还是没把握住题目的特征性和 dp 的整体架构。既然能一眼看出来是 dp 题，当根据题目特征，之后才有优化的资本。这是一般 dp 题的流程，重点在列出像样的 dp 式子，写一大坨不可用也不可优化的极端、特殊式子是没有意义的，要在把握 dp 的线性的基础上尝试状态转移，才能将千奇百怪的 dp 题化归成一套有迹可循的系统和。
强缓存和协商缓存的区别
hexadecimal_001的博客
10-05 713
强缓存定义：强缓存是指在浏览器发送请求前，先检查本地缓存中是否存在可用的资源副本。如果存在且未过期，则直接使用本地缓存，不向服务器发送请求。工作原理：当客户端首次请求资源时，服务器会在响应头中包含缓存控制信息，如（使用max-age指定资源的最大缓存时间）或Expires（指定资源的过期时间，是一个GMT格式的日期字符串）。客户端在后续请求时，会根据这些缓存控制信息判断是否使用本地缓存。协商缓存定义：协商缓存是指在浏览器发送请求后，服务器会先验证该资源是否被修改过。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值