redis-go源码阅读笔记

最新推荐文章于 2024-04-04 02:23:48 发布
最新推荐文章于 2024-04-04 02:23:48 发布
阅读量196 收藏
点赞数
分类专栏： redis 文章标签： redis 缓存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39679639/article/details/119336227
版权

底层数据结构

连接池pool

// redis连接池
type Pool struct {
	*pool.Slice  // 核心是Slice结构体
	c *Config // 连接池配置
		type Config struct {
			*pool.Config // 包含连接池配置，下面有详解

			Name         string
			Proto        string
			Addr         string
			Auth         string
			DialTimeout  xtime.Duration  // 请求拨号超时时长
			ReadTimeout  xtime.Duration  // 底层net.Conn读数据超时时长
			WriteTimeout xtime.Duration  // 底层net.Conn写数据超时时长
			SlowLog      xtime.Duration  // 慢查询阈值，默认250ms
		}
	statfunc func(ctx context.Context, name, addr, cmd string, t time.Time, err error) func() // 数据统计函数
}

// Slice .
type Slice struct {
	New  func(ctx context.Context) (io.Closer, error)  // 创建新连接函数
	stop func()

	mu           sync.Mutex
	freeItem     []*item  // 空闲连接池
	itemRequests map[uint64]chan item  // 记录正在请求连接池获取连接的协程及其req channel; 请求如果不能立即获取连接，会在这里新建一个chan，等待新连接写入
	nextRequest  uint64 // 递增值，记录当前等待连接的位置
	active       int // 当前活跃连接数

	openerCh  chan struct{}  // 用于接收新建连接信号的通道
	closed    bool  // 当前连接池是否关闭
	cleanerCh chan struct{}

	conf *Config // 连接池的配置信息，包括: 
		type Config struct {
			Active int // 同一时刻开启的最大连接数，包括Idle
			Idle int   // 连接池保持的最大空闲连接数, len(freeItem)
			IdelTimeout xtime.Duration // 连接空闲最大时长；空闲连接超过这个时间后会被清理；从freeItem中获取额连接，若存在时间超过该值，也会被销毁（这个很关键）
			WaitTimeout xtime.Duration // 获取连接等待时间；当连接池活跃连接数已满(p.active >= p.conf.Active)，Get()等待时间
			Wait bool // Get()是否等待连接；Wait = true，等待直到ctx超时；Wait = false，直接返回错误；Wait配置优先级低于WaitTimeout 
		}
}

连接conn

// 应用层使用的连接，Pool.Get()新建此数据结构并返回
type pooledConnection struct {
	p     *Pool
	rc    Conn  // raw conn, 一般为traceConn
	c     Conn  // 带超时的conn
	state int
	ctx   context.Context  // 应用层传入的ctx, Get(ctx)

	now  time.Time  // 好像固定为 beginTime, _ = time.Parse("2006-01-02 15:04:05", "2006-01-02 15:04:05")
	cmds []string
}

// pool中的实体，在底层Conn的基础上，增加日志等功能
type traceConn struct {
	tr trace.Trace
	trPipe trace.Trace

	connTags []trace.Tag // 连接值，包括ip，端口等信息

	Conn // 底层redis连接
	pending int
	
	slowLogThreshold time.Duration  // 慢日志阈值
}

// 底层Redis连接
type conn struct {
	mu      sync.Mutex
	pending int
	err     error
	conn    net.Conn  // 进行网络传输的net连接

	ctx context.Context

	readTimeout time.Duration  // 读buffer + 读超时时间
	br          *bufio.Reader

	writeTimeout time.Duration // 写buffer + 写超时时间
	bw           *bufio.Writer

	lenScratch [32]byte  // 还不太清楚，应该是用于解析resp.Body时使用的一些特殊字符等
	numScratch [40]byte
}

连接池 - 初始化 - NewPool()

// 初始化缓存池
func NewPool(c *Config, options ...DialOption) (p *Pool) {
	...
	// 初始化Slice
	p1 := pool.NewSlice(c.Config)
	// 定义新建连接函数
	p1.New = func(ctx context.Context) (io.Closer, error) {
		conn, err := Dial(c.Proto, c.Addr, ops...)
		if err != nil {
			return nil, err
		}
		return &traceConn{
			Conn:             conn,
			connTags:         []trace.Tag{trace.TagString(trace.TagPeerAddress, c.Addr)},
			slowLogThreshold: time.Duration(c.SlowLog),
		}, nil
	}
	p = &Pool{Slice: p1, c: c, statfunc: pstat}
	return
}

// 新建Slice
func NewSlice(c *Config) *Slice {
	ctx, cancel := context.WithCancel(context.Background())
	// 意味着，空闲连接池初始为空
	p := &Slice{
		conf:         c,
		stop:         cancel,
		itemRequests: make(map[uint64]chan item),
		openerCh:     make(chan struct{}, 1000000),
	}
	// 启动cleaner
	p.startCleanerLocked(time.Duration(c.IdleTimeout))
	// 启动opener
	go p.itemOpener(ctx)
	return p
}

在这里插入图片描述

Attention：官方不建议继续使用NewPool()获取连接池，可以使用NewRedis()代替。本质上没太大区别，只是Do()函数增加获取连接 + 释放连接的逻辑，应用层代码会简洁一些

连接池 - 获取连接 - Get()

在这里插入图片描述

获取连接这里有几个优先级：

  1. 先从空闲连接队列p.freeItem中获取，取到直接返回连接
  2. freeItem中没有，要看此时活跃连接数是否已达上线，未达上线则新建一个连接
    • 注意：freeItem中的空闲连接也在活跃连接p.active的统计中，即freeItem中的连接也是活跃连接
  3. 如果活跃连接数已达到上线，此时需要用到waitTimeout和wait两个配置参数，前者优先级更高
    • waitTimeout，表示连接数已达到上限时，Get()的阻塞时间（具体阻塞时间会在waitTimeout和ctx.timeout中取较小值，此时会报错context timeout，而非pool exhauted）
    • waitTimeout未设置时，wait配置生效，wait=true，表示Get()会一直阻塞，直到有连接给它，或者ctx超时
    • 若waitTimeout、wait均未设置，Get()直接抛错pool Exhausted

连接池 - 连接释放 - Put()

// 连接释放
func (p *Slice) Put(ctx context.Context, c io.Closer, forceClose bool) error {
	p.mu.Lock()
	defer p.mu.Unlock()
	// 强制关闭，p.active--, 连接关闭
	if forceClose {
		p.release()
		return c.Close()
	}
	// 正常情况下，归还连接到空闲队列或直接给其他等待连接的协程，如果操作失败，则直接关闭连接
	added := p.putItemLocked(c)
	if !added {
		p.active--
		return c.Close()
	}
	return nil
}

// 归还连接逻辑
func (p *Slice) putItemLocked(c io.Closer) bool {
	if p.closed {
		return false
	}
	// 如果活跃连接数比配置要大，则直接关闭连接
	if p.conf.Active > 0 && p.active > p.conf.Active {
		return false
	}
	// 重新封装item，更新连接的创建时间
	// 重要: 每次连接被释放后，会重置其创建时间
	i := item{
		c:         c,
		createdAt: nowFunc(),
	}
	// 先看是否有协程在等待连接，如果有，直接给他，传入它的等待通道req
	if l := len(p.itemRequests); l > 0 {
		var req chan item
		var reqKey uint64
		for reqKey, req = range p.itemRequests {
			break
		}
		delete(p.itemRequests, reqKey) // Remove from pending requests.
		req <- i
		return true
	// 再看空闲队列是否已满, 没满p.conf.Idle > len(p.freeItme)，则放入空闲队列，否则直接释放
	} else if !p.closed && p.maxIdleItemsLocked() > len(p.freeItem) {
		p.freeItem = append(p.freeItem, &i)
		return true
	}
	return false
}

连接 - 新建 - New()

// 在初始化连接池时，定义了新建连接函数
// 此新建的连接，是pool中存储的数据结构，非应用层使用的结构
// 应用层使用Get()获取连接，会在此返回的基础上封装成poolConnectedConn
func NewPool() () {
	...
	p1 := pool.NewSlice(c.Config)
	...
	p1.New = func(ctx context.Context) (io.Closer, error) {
		conn, err := Dial(c.Proto, c.Addr, ops...)
		if err != nil {
			return nil, err
		}
		return &traceConn{
			Conn:             conn,
			connTags:         []trace.Tag{trace.TagString(trace.TagPeerAddress, c.Addr)},
			slowLogThreshold: time.Duration(c.SlowLog),
		}, nil
	}
}

// 新建底层Redis连接，包括新建网络连接 + 定义网络超时
func Dial(network, address string, options ...DialOption) (Conn, error) {
	do := dialOptions{
		dial: net.Dial,
	}
	...
	// 这里会增加了几个Timeout
	...

	netConn, err := do.dial(network, address)
	if err != nil {
		return nil, errors.WithStack(err)
	}
	c := &conn{
		conn:         netConn,
		bw:           bufio.NewWriter(netConn),
		br:           bufio.NewReader(netConn),
		readTimeout:  do.readTimeout,
		writeTimeout: do.writeTimeout,
	}
	... 
	return c, nil
}

连接 - 执行 - Do()

// 应用层执行该Do函数
func (pc *pooledConnection) Do(commandName string, args ...interface{}) (reply interface{}, err error) {
	now := time.Now()
	ci := LookupCommandInfo(commandName)
	pc.state = (pc.state | ci.Set) &^ ci.Clear
	// 核心是这里，会调用其内部带超时时间的traceConn
	reply, err = pc.c.Do(commandName, args...)
	// 这里像是prometheus的数据上报，配置业务层Redis监控
	if pc.p.statfunc != nil {
		pc.p.statfunc(pc.ctx, pc.p.c.Name, pc.p.c.Addr, commandName, now, err)()
	}
	return
}

// traceConn在底层Conn.Do的基础上，增加打印慢日志
func (t *traceConn) Do(commandName string, args ...interface{}) (reply interface{}, err error) {
	statement := getStatement(commandName, args...)
	defer t.slowLog(statement, time.Now())
	// 源码初始化时，没有对t.tr的定义，所以Do应该只会走到这个if里，直接执行底层Conn.Do
	if t.tr == nil {
		return t.Conn.Do(commandName, args...)
	}
	...
}

// 底层Conn.Do 
func (c *conn) Do(cmd string, args ...interface{}) (reply interface{}, err error) {
	// 往net.Conn的写buffer里写入cmd, 这里有writeTimeout超时限制
	if cmd != "" {
		err = c.writeCommand(cmd, args)
	}
	...
	// 设置写超时readTimeout限制
	if c.readTimeout != 0 {
		c.conn.SetReadDeadline(shrinkDeadline(c.ctx, c.readTimeout))
	}
	// 从net.Conn的readBuffer中读取和解析内容，并返回
	for i := 0; i <= pending; i++ {
		var e error
		if reply, e = c.readReply(); e != nil {
			return nil, c.fatal(e)
		}
		if e, ok := reply.(Error); ok && err == nil {
			err = e
		}
	}
	return reply, err
}

// 底层网络连接对readTimeOut和writeTimeout的解释
type net.Conn interface {
	// SetReadDeadline sets the deadline for future Read calls
	// and any currently-blocked Read call.
	// A zero value for t means Read will not time out.
	SetReadDeadline(t time.Time) error

	// SetWriteDeadline sets the deadline for future Write calls
	// and any currently-blocked Write call.
	// Even if write times out, it may return n > 0, indicating that
	// some of the data was successfully written.
	// A zero value for t means Write will not time out.
	SetWriteDeadline(t time.Time) error
}

连接 - 执行 - SlowLog()

// redis sdk的慢日志在traceConn中记录，下面是traceConn在执行Do时的慢日志逻辑代码
// 记录时间即：底层Conn.Do()的执行时间
func (t *traceConn) Do(commandName string, args ...interface{}) (reply interface{}, err error) {
	statement := getStatement(commandName, args...)
	defer t.slowLog(statement, time.Now())
	if t.tr == nil {
		return t.Conn.Do(commandName, args...)
	}
}

// 执行时间大于慢日志阈值时，记录慢查询Warn日志
// 其中，slowLogThreshold即为配置文件中SlowLog的值，默认为250ms
func (t *traceConn) slowLog(statement string, now time.Time) {
	du := time.Since(now)
	if du > t.slowLogThreshold {
		log.Warn("%s slow log statement: %s time: %v", _tracePeerService, statement, du)
	}
}

连接 - 执行 - Close()

// 应用层执行该Close函数
func (pc *pooledConnection) Close() error {
	// 一些统计逻辑，不太懂，跳过
	...
	// 关键逻辑，将连接放回连接池
	pc.p.Slice.Put(context.Background(), pc.rc, pc.state != 0 || c.Err() != nil)
	return err
}

// 底层Conn.Close(), 关闭net.conn
func (c *conn) Close() error {
	c.mu.Lock()
	c.ctx = nil
	err := c.err
	if c.err == nil {
		c.err = errors.New("redigo: closed")
		err = c.conn.Close()
	}
	c.mu.Unlock()
	return err
}
勇敢的菜鸡
关注
专栏目录
Go 学习笔记（60）— Go 第三方库之 go-redis（初始化 redis、操作 string、操作 list、操作 set、操作 hset）
wohu1104的专栏
09-19 4786
1. 第三方库 go-redis 因为 Go 标准库中是没提供 redis 的库，所以我们选择用 go-redis 这个第三方库。源码地址为 https://github.com/go-redis/redis 在命令行中使用 go get 来安装 go get github.com/go-redis/redis 2. 初始化 Redis 在进行代码之前，需要先安装 redis，安装指导请参考：https://blog.csdn.net/wohu1104/article/details/867555
Redis学习笔记
qq_39183887的博客
10-24 518
Redis - Remote Dictionary Server ​ Redis官网：https://redis.io ​ Redis中文网：http://www.redis.cn ​ Redis所属公司：Pivotal（Spring所在的公司） ​ Redis源码地址：https://github.com/antirez/redis 1. NoSQL - Not Only SQL ​ MySQL、Oracle、DB2：关系型数据库 ​ 结构化数据：使用关系型数据库表示和存储，表现形式就是二维行
redis源码阅读—dict(字典结构)
qq_36581961的博客
12-29 970
文章目录前言常用API介绍逻辑结构图结构定义字典哈希表哈希表节点rehash图解rehash条件rehash实现渐进式rehash图解源码阅读创建并初始化字典字典添加字典替换字典删除 前言 Redis 的字典使用哈希表作为底层实现， 一个哈希表里面可以有多个哈希表节点， 而每个哈希表节点就保存了字典中的一个键值对。 接下来将介绍 Redis 的哈希表、哈希表节点、以及字典的实现，包括字典实现的源码分析。 常用API介绍 #hset 插入数据 hset myhash name zhangsan age 22
read-goredis:阅读goredis-golang redis客户端源码笔记
03-23
Golang的Redis客户端 支持： Redis 3命令（QUIT，MONITOR，SLOWLOG和SYNC除外）。 具有支持的自动连接池。 。 。 和 。 。 。 。 。 不使用集群模式和Redis Sentinel 集群。 。 。 。 。 。 API文档： : 。 范例： : 。 安装 go-redis需要具有支持的Go版本，并使用导入版本控制。 因此，请确保在安装go-redis之前初始化Go模块： go mod init github.com/my/repo go get github.com/go-redis/redis/v7 进口： import "github.com/go-redis/redis/v7" 快速开始 func ExampleNewClient () { client := redis . NewClient (
go-redis 连接池源码分析
浴血重生-学习空间
12-27 602
1、建立连接和关闭连接 2、池子里面取Conn的管理 3、监控统计 4、整个Pooler池子的关闭 结构体 type ConnPool struct { opt *Options //初始化的配置项 dialErrorsNum uint32 // atomic 连接错误次数 lastDialError error //连接错误的最后一次的错误类型 lastD...
Go-Redis 使用与源码分析
CoLiuRs
09-14 1777
通常，连接错误记录是读多写少的，所以采用读写锁来保证该记录的并发安全（读写锁在该场景下性能更佳）。// 加锁 p . lastDialErrorMu . RLock() err := p . lastDialError。
Go语言访问redis
05-30
Go语言访问Redis项目，主要介绍各种方式访问redis 写入値和读写値，方便，快速。。。
go-redis快速入门教程（附仓库源码）
golibec的专栏
03-14 646
【代码】go-redis快速入门教程（附仓库源码）
韩顺平java笔记和源码-golang:高朗
06-06
这份笔记是笔者自学Golang时的资料总结，结合了很多书籍、博主以及开源作品的内容。 笔者也收到了大量的反馈和建议，笔记仍然会在我的学习旅程中不断更新，绝对不鸽。 很多章节仍然在完善中，如Go在微服务中的实践、...
Redis 6.0 源码阅读笔记(10) -- 主从复制 Master 节点流程分析
alpha_love的博客
05-09 658
1. 主从复制中 Master 节点的处理 Redis 主从复制 一节中粗略介绍过 Redis 的主从复制存在两种模式，以下则是 Master 节点对于主从复制的处理： 接收 Slave 节点的 psync 命令 判断是否可以执行部分复制，可以的话回复 +CONTINUE 给 Slave 节点，并将缓冲区命令直接发送给 Slave 节点，完成同步；不可以执行部分复制，只能全量复制，则回复 +FULLRESYNC 给 Slave 节点，根据情况做下一步处理 Master 节点存在可以复用的 rdb 数据，则
godis:Golang实现的Redis服务器
04-29
神是 Godis是Redis Server的简单实现，旨在提供使用golang编写高并发中间件的示例。 请注意，切勿考虑在生产环境中使用此功能。 Gods实现了redis的大多数功能，包括5种数据结构，ttl，发布/订阅，geo和AOF持久性。 Godis可以作为对客户端透明的服务器端群集运行。 您可以连接到集群中的任何节点以访问集群中的所有数据： 如果您会读中文，则可以在“找到更多详细信息。 开始使用 您可以在此存储库的发行版中获得可运行的程序，该存储库支持Linux和Darwin系统。 ./godis-darwin 您可以使用redis-cli或其他redis客户端连接godis服务器，该服务器在默认模式下侦听127.0.0.1:6379。 该程序将尝试从环境变量CONFIG读取配置文件路径。 如果未设置环境变量，则程序尝试读取工作目录中的redis.conf 。 如
Go-Redis-cli的一个纯Go实现
08-14
Redis-cli的一个纯Go实现
redis：用Go Golang编写的Redis服务器（原型）
02-05
在Go中成为完整的Redis实施 这个项目开始了解在Go中实现完整的Redis克隆有多么容易。 作为副作用之一，想象一下您可以在Go中编写redis模块，那太好了！ 参与其中！ 该项目正在进行中，因此可以共享想法，代码并享受乐趣。 目标是拥有所有功能和命令，例如用C编写的实际 。 我们正在寻找贡献者！ 文献资料 godoc： ：//godoc.org/github.com/redis-go/redis 入门 您已经可以测试API。 要安装，请运行： go get -u github.com/redis-go/redis 路线图 客户端连接/请求/响应 RESP协议 能够注册命令
redis2go:小型Redis内存实现
05-16
Redis2Go 这是命令子集的实现。 特别是： 设置键值 SET键值EX秒（不需要实现其他SET选项） GET键 DEL键 DBSIZE INCR键 ZADD关键分数成员 ZCARD钥匙 ZRANK关键成员 ZRANGE键启动停止 轻量级架构决策记录 我们使用 ，因此重大决策是合理的，并将其放在上下文中以供将来考虑。 在您的项目中安装 您将需要Node v6.10.3和npm 。 打包后的内容已在上发布，因此您可以将其添加到JS项目中。 npm install redis2go --save 使用范例 const Redis2Go = require ( './redis2go' ) const client = new Redis2Go ( ) client . set ( 100 ) . then ( result => console . log ( result )
Go-redis-一个简单的强大的Redis的Go客户端
08-13
redis - 一个简单的、强大的 Redis的Go客户端
Java详解：如何实现一个-redis-缓存服务，字节跳动+阿里+华为+腾讯等大厂Java面试题
最新发布
2401_83974607的博客
04-04 1036
在这个接口类中，主要定了下面的接口顺便给大家推荐一个Java技术交流群：473984645里面会分享一些资深架构师录制的视频资料：有Spring，MyBatis，Netty源码分析，高并发、高性能、分布式、微服务架构的原理，JVM性能优化、分布式架构等这些成为架构师必备的知识体系。还能领取免费的学习资源，目前受益良多！这些接口分别用于存储不过期的对象、存储将来过期对象、获取缓存对象、获取缓存对象剩余存活时间、删除缓存对象、设置缓存对象过期时间、清除所有缓存对象的功能/**
redis集群搭建，基于go-redis的客户端链接以及集群客户端底层源码分析
lcl20093466的博客
01-10 211
redis集群搭建，基于go链接集群，分析客户端集群执行命令流程
开源 redis 客户端 redigo 源码学习
pj81102的专栏
06-22 654
redigo 介绍 Go语言实现的开源 redis 客户端。 特性 提供类似 print 函数风格(Print-like)的 API，支持所有的 redis 命令； 支持流水线事务(pipelined transaction)； 支持发布/订阅机制； 支持使用连接池，提高并发操作； Lua 脚本辅助类型(script helper type)，经过优化的 EVALSHA 功能； 应答...
Redis实现服务注册与服务发现源码阅读（Go语言）
weixin_44522586的博客
03-04 967
服务注册与服务发现redis方案源码解读
使用shell编写一个redis-stable源码编译部署脚本
04-25
好的，以下是一个简单的shell脚本，可以编译和部署redis-stable源码： ``` #!/bin/bash # 安装编译redis所需的依赖 sudo apt-get update sudo apt-get install build-essential tcl -y # 下载redis源代码 cd /tmp curl -O http://download.redis.io/redis-stable.tar.gz # 解压源代码 tar xzvf redis-stable.tar.gz # 编译redis cd redis-stable make # 部署redis sudo make install # 启动redis服务 redis-server ``` 请注意，这只是一个简单的脚本，可能需要根据不同的操作系统或更复杂的环境进行修改。建议在实际生产环境中测试和修改脚本。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值