Go-Zero框架上手前奏4: 深入 net/rpc 请求调度与源码实现

从零开始学习 Go 1.25 编程 今天是你新生活的第一天,无论年龄、背景如何,改变从这一刻开始。CodeGym帮助成千上万普通人转型为程序员,从零基础到掌握Go语言,完成真实项目,甚至入职心仪岗位。Go语言简洁高效,适合服务器端开发,是云基础设施、微服务和高负载系统的首选。2026年正是入行良机,你的经验反而是优势。别犹豫,迈出第一步,你将收获技能、自信与全新人生。🚀 阅读详情

纲要

  • 阅读源码的方法论
    • 明确目标
    • 先构思、后验证
    • 以问题驱动源码阅读
  • RPC 调度需要解决的核心问题
    • 请求与响应的数据格式
    • 多种编码方式的集成
    • 从请求到具体方法的映射与调度
  • 注册流程分析
    • 利用 reflect 获取服务名和方法集
    • 以 sync.Map 存储服务与方法映射
  • 请求调度流程分析
    • 从连接读取请求信息
    • 通过编解码器(codec)反序列化请求
    • 根据服务名与方法名查找并调用对应方法
  • 源码验证(net/rpc 标准库)
    • Server.Register 的反射与注册逻辑
    • Server.serveRequest 的读取与调度路径
    • 编解码器的解耦设计
  • 总结

在微服务与分布式系统中,RPC(远程过程调用)是基石之一。Go 语言标准库自带的 net/rpc 包虽然功能有限,但它的设计与调度思路极具代表性,读透它对构建自己的 RPC 框架会很有帮助。本文将结合源码阅读的一般方法,逐步拆解 net/rpc 在服务注册与请求调度背后的实现原理。

阅读源码的方法论

很多开发者在初次接触标准库或框架源码时,容易陷入“看不懂、绕来绕去、无从下手”的局面。其实症结通常有三个:

  1. 目标模糊——不清楚自己想从源码中得到什么;
  2. 直接硬读——没有基于自己的理解先构思一个大致实现,导致思维被牵着走;
  3. 畏惧复杂调度——面对跨模块调用、并发处理时难以理清脉络。

一种更高效的方式是:先确定要解决的问题,然后闭上眼睛想一想如果自己来实现会怎么做,最后再带着这个“假想实现”去对比源码,验证或修正自己的设计。这样每一次源码阅读都变成了一次“设计讨论”,收获会大不相同。

下面我们就用这套思路,来分析 net/rpc 的调度原理。

RPC 调度要解决的核心问题

要实现一个基本的 RPC 框架,至少需要回答下面三个问题:

核心问题说明
消息编码与传输格式请求和响应在网络上以什么格式传输?如何定义结构体?
多编码方式集成怎么支持 JSON、Gob 甚至自定义编码,而不与核心调度耦合?
请求到方法的映射客户端传来一个字符串“服务名.方法名”,怎样精准地调用到对应的实际方法?

在 net/rpc 标准库中,请求和响应的数据结构已经定义好(Request 和 Response)。编码方式则通过 ServerCodec 接口抽象,默认提供了 Gob 编码,也允许替换为 JSON。最关键的是第三点:如何从字符串映射到方法调用,这就衍生出了注册与调度两套机制。

我们可以构思一个简化的实现方案:

  • 注册时,利用反射拿到服务的类型名称,并遍历其所有导出方法,将它们存入一个 map,键为“ServiceName.MethodName”,值为方法的反射调用信息。
  • 调度时,从请求中解析出服务名和方法名,到 map 里查找,找到后通过反射调用。

带着这样的想象,我们再去源码中寻找证据和差异。

注册流程分析

服务的注册入口是 rpc.Register 或 rpc.RegisterName。内部会创建一个默认的 Server 实例,并调用其 Register 方法。

简化后的注册过程可以抽象为以下代码意图:

func (server *Server) Register(rcvr interface{}) error {
    // 使用反射获取 rcvr 的类型与值 
    typ := reflect.TypeOf(rcvr)
    val := reflect.ValueOf(rcvr)
    // 获取服务名称:优先使用自定义名称,否则取类型的字符串表示 
    sname := reflect.Indirect(val).Type().Name()
    // 遍历方法,筛选出符合 RPC 签名的方法 
    methods := suitableMethods(typ)
    // 以服务名为 key,将 (服务名, 方法集) 存入 sync.Map 
    server.serviceMap.Store(sname, &service{
        name:    sname,
        rcvr:    val,
        method:  methods,
    })
    return nil 
}

在真正的源码中,你会看到:

  • 当没有显式指定服务名时,通过 reflect.Indirect(reflect.ValueOf(rcvr)).Type().Name() 获取结构体的名称作为服务名。
  • 之后遍历所有方法,按照约定的签名(方法必须有两个参数:一个指针类型的请求参数,一个指针类型的响应参数,并返回一个 error)进行筛选。
  • 筛选后的方法集和接收者一起被组装成一个内部 service 对象,并存入一个 sync.Map。使用同步 map 是为了在并发注册和调度时避免锁竞争。

这一设计与我们之前的构想几乎一致:以字符串为键存储服务与方法,为后续的快速查找做准备。

下图展示了注册流程:

sync.MapreflectServer使用者sync.MapreflectServer使用者Register(service)获取类型名称服务名 "HelloService"遍历方法,筛选符合签名的导出方法方法列表 [SayHello, ...]Store("HelloService", service{name, rcvr, methods})注册完成

请求调度流程分析

当客户端通过网络将请求发送到服务端后,Server 会在 Accept 循环中为每个连接启动一个 goroutine,核心调度发生在 serveRequest 方法中。

简化的调度流程可表示为:

func (server *Server) serveRequest(codec ServerCodec) error {
    // 1. 从 codec 中读取请求 
    req, err := server.readRequest(codec)
    // 2. 根据服务名查找 service 
    svc, mtype, err := server.lookupMethod(req.ServiceMethod)
    // 3. 准备调用参数并执行方法 
    argv := ... // 根据 mtype 反射构造请求参数 
    replyv := ... // 构造响应参数 
    returnValue := mtype.method.Func.Call([]reflect.Value{svc.rcvr, argv, replyv})
    // 4. 将响应写回 
    server.sendResponse(codec, replyv, ...)
}

在真实源码中,readRequest 会与 codec 交互,完成头部和包体的读取及反序列化。编解码器 ServerCodec 是一个接口,定义了 ReadRequestHeader、ReadRequestBody、WriteResponse 等方法,这正是实现多编码方式集成的关键:你只需实现该接口,就可以将 net/rpc 的传输层与任何序列化协议搭配使用。

而 lookupMethod 的内部逻辑正是利用字符串切割将 "Service.Method" 拆分为服务名和方法名,然后从 sync.Map 中取出对应的 service 和 method 反射对象。这与我们最初构思的“基于 map + 字符串查找”完全吻合。

调度的序列图如下:

reflectsync.MapCodecServerClientreflectsync.MapCodecServerClient网络连接,传入请求数据ReadRequestHeader & ReadRequestBodyServiceMethod, ArgsLoad(ServiceName)service & method构造参数并 Call返回结果或错误WriteResponse响应数据

源码验证与深入

在 net/rpc 中,server.go 是核心文件。你可以清晰地看到:

  • serviceMap 是一个 sync.Map,用于存储所有已注册的服务。
  • Register 中确实使用了反射来推导名称和方法列表。
  • serveRequest 中创建了一个 gobServerCodec(默认),然后调用 readRequest 进行请求读取,其中包含了对 codec 的调用。
  • 调度发生在 call 相关逻辑中,通过 method.Func.Call 完成真正的反射调用。

整个调度代码并不复杂,但它奠定了标准库 RPC 模块的基石,也为我们构建自定义 RPC 框架提供了极佳的参考范本。

附:一个可运行的简易 RPC Demo

下面我们基于前面分析的核心机制,实现一个最小化的 RPC 库。它仅依赖标准库的 net、reflect 和 encoding/json,完整演示服务注册、请求解码、方法调度和响应返回的全过程。

整体设计

  • 通信协议:使用 TCP,请求与响应均编码为 JSON 行(以 \n 分隔)。
  • 请求结构:包含 ServiceMethod、Args 和 Seq(请求序号)。
  • 响应结构:包含 Seq、Reply 和 Error。
  • 注册表:用 map[string]*service 存储,通过读写锁保护。
  • 调度:从请求中解析出服务名和方法名,查找注册表,利用反射调用目标方法。

完整代码

将以下代码保存为 main.go,然后使用 go run main.go 启动服务端,再通过另一个终端以客户端模式运行即可。

package main 
 
import (
	"bufio"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"log"
	"net"
	"os"
	"reflect"
	"strings"
	"sync"
)
 
// 请求与响应结构 
type Request struct {
	ServiceMethod string          `json:"method"` // "Service.Method"
	Args          json.RawMessage `json:"args"`   // 客户端传来的参数 JSON 
	Seq           uint64          `json:"seq"`    // 请求序号,用于匹配响应 
}
 
type Response struct {
	Seq   uint64          `json:"seq"`
	Reply json.RawMessage `json:"reply,omitempty"`
	Error string          `json:"error,omitempty"`
}
 
// 服务端内部结构 
type methodType struct {
	method reflect.Method 
	argType reflect.Type  // 请求参数的类型 
}
 
type service struct {
	name    string 
	rcvr    reflect.Value 
	typ     reflect.Type 
	methods map[string]*methodType 
}
 
type Server struct {
	mu       sync.RWMutex 
	services map[string]*service 
}
 
func NewServer() *Server {
	return &Server{services: make(map[string]*service)}
}
 
// 注册一个服务对象,要求其所有导出方法符合 func(req *T, resp *U) error 签名 
func (s *Server) Register(rcvr interface{}) error {
	s.mu.Lock()
	defer s.mu.Unlock()
 
	val := reflect.ValueOf(rcvr)
	typ := reflect.Indirect(val).Type()
	sname := typ.Name()
 
	if _, ok := s.services[sname]; ok {
		return errors.New("rpc: service already defined: " + sname)
	}
 
	svc := &service{
		name:    sname,
		rcvr:    val,
		typ:     typ,
		methods: make(map[string]*methodType),
	}
 
	for i := 0; i < typ.NumMethod(); i++ {
		method := typ.Method(i)
		mtype := method.Type 
		// 检查签名:3 个输入参数(receiver, 指针参数, 指针参数),1 个输出 error 
		if mtype.NumIn() != 3 || mtype.NumOut() != 1 {
			continue 
		}
		argType := mtype.In(1)
		if argType.Kind() != reflect.Ptr {
			continue 
		}
		replyType := mtype.In(2)
		if replyType.Kind() != reflect.Ptr {
			continue 
		}
		if returnType := mtype.Out(0); returnType != reflect.TypeOf((*error)(nil)).Elem() {
			continue 
		}
		svc.methods[method.Name] = &methodType{
			method:  method,
			argType: argType.Elem(),
		}
	}
 
	if len(svc.methods) == 0 {
		return errors.New("rpc: no exported methods with correct signature for: " + sname)
	}
 
	s.services[sname] = svc 
	return nil 
}
 
// 处理单个连接 
func (s *Server) ServeConn(conn net.Conn) {
	defer conn.Close()
	reader := bufio.NewReader(conn)
	writer := bufio.NewWriter(conn)
	for {
		line, err := reader.ReadBytes('\n')
		if err != nil {
			if err != io.EOF {
				log.Println("rpc: read error:", err)
			}
			break 
		}
		var req Request 
		if err := json.Unmarshal(line, &req); err != nil {
			s.sendError(writer, req.Seq, "invalid request: "+err.Error())
			continue 
		}
		go s.handleRequest(writer, &req)
	}
}
 
func (s *Server) handleRequest(writer *bufio.Writer, req *Request) {
	parts := strings.SplitN(req.ServiceMethod, ".", 2)
	if len(parts) != 2 {
		s.sendError(writer, req.Seq, "invalid service method format")
		return 
	}
	serviceName, methodName := parts[0], parts[1]
 
	s.mu.RLock()
	svc, ok := s.services[serviceName]
	s.mu.RUnlock()
	if !ok {
		s.sendError(writer, req.Seq, "service not found: "+serviceName)
		return 
	}
 
	mtype, ok := svc.methods[methodName]
	if !ok {
		s.sendError(writer, req.Seq, "method not found: "+methodName)
		return 
	}
 
	// 构造参数实例 
	argv := reflect.New(mtype.argType)
	if err := json.Unmarshal(req.Args, argv.Interface()); err != nil {
		s.sendError(writer, req.Seq, "unmarshal args: "+err.Error())
		return 
	}
 
	replyv := reflect.New(mtype.method.Type.In(2).Elem())
 
	// 调用方法 
	returnValues := mtype.method.Func.Call([]reflect.Value{svc.rcvr, argv, replyv})
	if errInter := returnValues[0].Interface(); errInter != nil {
		s.sendError(writer, req.Seq, errInter.(error).Error())
		return 
	}
 
	replyBytes, _ := json.Marshal(replyv.Interface())
	resp := Response{
		Seq:   req.Seq,
		Reply: replyBytes,
	}
	respBytes, _ := json.Marshal(resp)
	writer.Write(append(respBytes, '\n'))
	writer.Flush()
}
 
func (s *Server) sendError(writer *bufio.Writer, seq uint64, msg string) {
	resp := Response{Seq: seq, Error: msg}
	respBytes, _ := json.Marshal(resp)
	writer.Write(append(respBytes, '\n'))
	writer.Flush()
}
 
// 启动服务监听 
func (s *Server) ListenAndServe(addr string) error {
	ln, err := net.Listen("tcp", addr)
	if err != nil {
		return err 
	}
	log.Println("rpc server listening on", addr)
	for {
		conn, err := ln.Accept()
		if err != nil {
			log.Println("accept error:", err)
			continue 
		}
		go s.ServeConn(conn)
	}
}
 
// ---------- 客户端辅助 ----------
type Client struct {
	conn   net.Conn 
	writer *bufio.Writer 
	reader *bufio.Reader 
	mu     sync.Mutex 
	seq    uint64 
}
 
func Dial(addr string) (*Client, error) {
	conn, err := net.Dial("tcp", addr)
	if err != nil {
		return nil, err 
	}
	return &Client{
		conn:   conn,
		writer: bufio.NewWriter(conn),
		reader: bufio.NewReader(conn),
	}, nil 
}
 
func (c *Client) Call(serviceMethod string, args interface{}, reply interface{}) error {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.seq++
	seq := c.seq 
 
	argsBytes, err := json.Marshal(args)
	if err != nil {
		return err 
	}
	req := Request{
		ServiceMethod: serviceMethod,
		Args:          argsBytes,
		Seq:           seq,
	}
	reqBytes, _ := json.Marshal(req)
	_, err = c.writer.Write(append(reqBytes, '\n'))
	if err != nil {
		return err 
	}
	c.writer.Flush()
 
	line, err := c.reader.ReadBytes('\n')
	if err != nil {
		return err 
	}
	var resp Response 
	if err := json.Unmarshal(line, &resp); err != nil {
		return err 
	}
	if resp.Error != "" {
		return errors.New(resp.Error)
	}
	if reply != nil {
		return json.Unmarshal(resp.Reply, reply)
	}
	return nil 
}
 
func (c *Client) Close() error {
	return c.conn.Close()
}
 
// ---------- 示例服务 ----------
type Arith struct{}
 
type Args struct {
	A, B int 
}
 
type Reply struct {
	C int 
}
 
func (a *Arith) Add(args *Args, reply *Reply) error {
	reply.C = args.A + args.B 
	return nil 
}
 
func (a *Arith) Sub(args *Args, reply *Reply) error {
	reply.C = args.A - args.B 
	return nil 
}
 
// ---------- main ----------
func main() {
	if len(os.Args) < 2 {
		fmt.Println("Usage: go run main.go server|client")
		return 
	}
	switch os.Args[1] {
	case "server":
		srv := NewServer()
		if err := srv.Register(new(Arith)); err != nil {
			log.Fatal("register error:", err)
		}
		log.Fatal(srv.ListenAndServe(":12345"))
	case "client":
		client, err := Dial(":12345")
		if err != nil {
			log.Fatal("dial error:", err)
		}
		defer client.Close()
 
		args := &Args{A: 10, B: 3}
		var reply Reply 
 
		if err := client.Call("Arith.Add", args, &reply); err != nil {
			log.Fatal("call Add error:", err)
		}
		fmt.Printf("Add: %d + %d = %d\n", args.A, args.B, reply.C)
 
		if err := client.Call("Arith.Sub", args, &reply); err != nil {
			log.Fatal("call Sub error:", err)
		}
		fmt.Printf("Sub: %d - %d = %d\n", args.A, args.B, reply.C)
	}
}

运行方式

1 ) 启动服务端:

go run main.go server

2 ) 在另一个终端启动客户端:

go run main.go client 

3 ) 你将看到类似输出:

Add: 10 + 3 = 13 
Sub: 10 - 3 = 7 

关键点解析

  • 注册:Server.Register 遍历结构体的所有方法,筛选出签名正确的方法并存入 map。
  • 调度:handleRequest 解析请求中的 Service.Method,从 map 中查找对应服务和方法,通过反射创建参数并调用。
  • 编码:使用 json.RawMessage 延迟解码,在方法调用前才将 Args 反序列化为具体参数类型。
  • 并发:每个连接独立处理,每个请求在单独的 goroutine 中执行,读写锁保证服务注册表安全。

这个 Demo 虽然精简,却完整覆盖了 net/rpc 的核心调度思路。你可以在此基础上添加超时控制、连接池、更多编码支持,甚至与 go-zero 的设计理念进行对比,进一步加深对 RPC 框架的理解。

总结

本文我们从“自己先构思”出发,然后对照 net/rpc 源码,验证了服务注册与请求调度两大部分的设计。核心思路可以概括为:

  • 注册:反射提取服务名和方法集,存入线程安全的 sync.Map。
  • 调度:从编解码器读取请求,解析出服务名和方法名,从 sync.Map 查找反射信息,最终通过反射发起调用。
  • 编码解耦:通过 ServerCodec 接口将序列化逻辑与调度逻辑分离,使得扩展新协议变得简单。

理解这些机制后,再去阅读其它 RPC 框架(如 gRPC、rpcx、go-zero)的内部实现,你会发现很多异曲同工之处。更重要的是,这种“先构思后验证”的源码阅读方式,值得在每一次深入技术内核时反复运用。

Go 语言数据库事务详解:从 db.Begin 到 Tx 的正确用法 本文详解Go语言中database/sql事务的正确用法,从*sql.Tx的底层模型出发,阐述事务与连接池的关系,提供标准事务模板,并强调使用db.BeginTx控制隔离级别与超时。重点剖析常见陷阱:误用db而非tx执行SQL、defer顺序错误、忽略Commit错误、事务过长导致资源耗尽等。结合可运行示例,涵盖事务内查询、预处理语句及保存点模拟嵌套事务,全面覆盖工程实践中的关键细节。 阅读详情

相关推荐

【博弈论基础与几大经典模型】古诺模型、斯塔克尔伯格模型Stackelberg Game、价格领导模型、Bertrand模型、Sweezy模型

博弈论中经典模型☞古诺模型、斯塔克尔伯格模型、价格领导模型等

学习记录 3万+

每天10分钟学Go:第5课 switch分支判断

本课程讲解 Go 语言 switch 分支判断核心用法,涵盖单值匹配、多 case 合并、无表达式条件分支、fallthrough 穿透与类型 switch 断言,搭配可运行代码示例,带你掌握 Go 分支结构语法与实战写法。

2501_94567985的博客 260

锁定放大器

锁定放大器

qq_46757048的博客 4706

每天10分钟学Go:第9课 Range循环

在 Go 里,`range` 常用来遍历切片、数组、字符串、映射和通道。它会在每次循环时,把当前元素的信息交给循环变量。前面《》我们已经会写普通的for循环,可以把range理解成一种更方便的遍历方式。

2501_94567985的博客 195

STM32Cubemx-H7-17-麦克纳姆轮驱动

我们先看.h,知道哪些函数会有哪些功能和宏定义参数首先 是在.h的宏定义处定义引脚编号,比如tb6612控制方向的引脚,以及设定了哪个定时器作为pwm输出,还有编码计次的中断引脚/* 硬件相关宏定义 *//*1 前进方向往上 42 3*/// TB6612 方向引脚定义/* 定时器相关宏定义 *//* 编码器相关宏定义 */把自己的引脚根据原理图填对应,方向引脚也是,如果发现反转就把对应的引脚定义反过来,编码也是,编码我们用一个引脚就好,都在cubemx配置好。

m0_74211379的博客 1423

2026闲鱼数据采集实战:本地YOLO识别滑块验证码+接口签名分析+零成本价格监控系统

2026闲鱼反爬系统升级实战:零成本解决方案 本文针对2026年闲鱼最新反爬机制提出了一套完整的零成本解决方案。系统面临四大挑战:AI滑块验证、接口签名升级、设备指纹绑定和精细化行为检测。通过以下技术突破实现稳定运行: 本地化AI破解:训练YOLOv11n模型实现98%准确率的滑块识别,替代付费打码平台 逆向工程:Hook闲鱼App签名算法,用Python重写HMAC-SHA256签名生成器 设备指纹管理:建立"一机一号一IP"机制,维护50+种设备特征 行为模拟:开发四阶段滑动轨迹模型

专注于Python爬虫开发,分享爬虫技巧、项目实战与反爬经验,使用Scrapy、BeautifulSoup等工具,解决数据抓取难题。 1462

TinyGo 驱动 ESP32 端侧 AI 推理实战:纯 Go 实现轻量机器学习模型部署全流程

基于乐鑫官方 TinyGo 教程,从零实现纯 Go 语言开发 ESP32 端侧 AI 推理应用,覆盖环境搭建、模型转换到全流程部署。

嵌入式扫地僧 520

Win11下VSCode配置Python虚拟环境:从venv原理到高效开发实战

Python虚拟环境是解决项目依赖冲突、保障环境隔离性的核心技术,其核心原理是通过创建独立的Python解释器与包目录,实现不同项目间的依赖隔离。在工程实践中,虚拟环境能确保开发、测试与部署环境的一致性,提升代码的可复现性与团队协作效率。对于Windows 11平台下的Python开发者,结合轻量强大的VSCode编辑器,可以构建一套标准化的开发工作流。本文以Python内置的venv模块为例,详解如何在VSCode中创建、激活与管理虚拟环境,并配置自动化终端激活、代码格式化(如autopep8)与调试功能

weixin_33693070的博客 427

2026-11-11-Go分布式锁实战

线上偶发重复扣库存,查了半天是业务执行超过了锁的过期时间,锁提前释放,另一个请求拿到锁又执行了一遍。单机锁在多实例部署下失效,Redis SET NX PX 加锁、Lua 脚本原子释放、看门狗续期,这篇讲透分布式锁三大坑,附实现对照表和实战清单。

利威尔的博客,主要分享一些go后端,agent相关知识,都是最新最前沿而且是免费的,在我的专栏里有各种方向的详细分类和内容整理,详细内容请阅读主页置顶文章,希望对你有帮助。 297

C# MES通信从入门到精通(1)——串口传输文件

本文详细介绍了在Mes通信领域如何使用串口发送文件,由实战经验总结,堪称MES通信领域的葵花宝典!

qq_34059233的博客 3754

lammps教程:官方自带eam_database程序拟合EAM势方法介绍

使用lammps模拟金属体系,最常用的势函数为eam、meam势。 对于大多数金属或者合金来说,可以从网上下载相对应的eam或meam势力场文件。 而对于一些新的合金材料,可能就找不到相对应的力场文件。 解决的方法有两种,一是采用混合势(pair_style hybrid),第二种方法是自己拟合势函数文件。 混合势的写法在前面文章中已经介绍过,本文介绍一种拟合EAM势的方法。 该方法是运行Xiaowang Zhou编写的一个拟合程序,该程序可自动生成所需要的合金势。 这个程序能够拟合的合金元素有: Cu,

lammps_jiayou的博客 4619

Go 泛型入门:类型参数、约束与 Map/Filter/Stack

掌握类型参数、约束、~ 与 union,写出通用 Map/Filter/Stack,并知道什么时候不该用泛型。

JudithHuang的博客 217

Spring AI提示词模板应用

本文介绍了使用SpringAI提示词模板的配置方法,主要步骤包括:1)在JDK17和SpringBoot3.4.4环境下引入spring-ai-alibaba1.0.0.2依赖;2)配置application.yml文件;3)创建测试控制器类处理提示词模板(.st文件);4)通过模板变量动态生成AI回复内容。演示了如何通过@RequestParam设置默认参数,实现无需前端传参即可测试AI回复功能,最终完成了一个SpringAI提示词模板的应用Demo。

wjianwei666的专栏 202

每天10分钟学Go:第1课 环境搭建与第一个Go程序

本号专注分享实战干货、避坑指南、性能调优、面试重难点, 每一篇都是亲手落地测试,帮你少走弯路、快速提升核心竞争力。5、将go程序构建成可执行的二进制文件:go build hello-world.go。3、编辑go文件写入程序:vim hello-world.go。4、运行go程序:go run hello-world.go。2、创建go文件:touch hello-world.go。1、创建项目目录:mkdir go-test261111。2、配置go环境变量。

2501_94567985的博客 124

怀旧版电脑GBC模拟器

再现原版GBC掌机的界面,电脑运行连游戏界面都一样大小,很怀旧,很真实,(英文版)强烈推荐,很小的文件,很难才找到的。

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

Go 测试实战:表驱动、Benchmark 与 httptest

从表驱动、子测试到 Benchmark/Fuzz/httptest,建立“测行为不测实现”的测试习惯。

JudithHuang的博客 213

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

day01-认识Go语言 + golang环境的安装

Go语言由Google开发,2009年发布,兼具编译型性能与脚本语言易用性。其优势包括运行快、语法简洁、跨平台构建、丰富标准库及原生并发支持(goroutine与channel),适用于微服务、区块链等场景。安装时需配置GOROOT(安装路径)、GOPATH(工作空间,含pkg和bin目录)及GOBIN,并将%GOROOT%\bin、%GOBIN%、%GOPATH%加入系统Path。通过命令行验证环境后,可使用GoLand等IDE进行开发,快速上手高效编程。

2301_77190282的博客 239

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

Go1.25 升级后 GoLand 调试提示【变量不可用】解决方案

顶部菜单Help→在弹出的配置文件中添加下面一行,路径替换为你本机 dlv.exe 真实路径Windows 路径使用正斜杠,不要用反斜杠保存配置文件,完全重启 GoLand(不是只重启调试会话)Go 大版本升级后,优先检查 Delve 兼容性,这是 Go1.24+、Go1.25 最常见的调试踩坑点。升级dlv + 指定dlv路径 + 关闭编译优化参数,90% 的“变量不可用”问题都可以解决。

关于代码的那些事 251

深入浅出Go-pprof设计思想

本文以“不打扰的城市”为隐喻,生动诠释了Go语言pprof性能分析工具的核心理念:观测不应改变被观测对象。通过城市巡夜、速记员、账本等角色,类比pprof中SIGPROF、sigprof、profBuf等组件,揭示其低干扰采样机制——定时随机抽查、不携带额外开销、数据写入即丢、最终生成可视化火焰图。整套设计确保程序在被监控时仍保持原速运行,真正实现“看清系统而不影响系统”。

不愿言弃-念何的博客 509

Go 定时任务实战:工业边缘场景下的 robfig/cron

工业边缘网关里有大量周期性工作:设备状态轮询、数据同步、定时上报、日志清理。,本文从角度梳理其用法、任务封装、并发控制与常见的坑。

ZenovaEdgeOS的博客 459

Go FX 依赖注入框架:从入门到实战

FX 的核心思想就是“声明式依赖管理”—— 你只需要告诉它"我有这些组件,它们需要什么",剩下的创建、排序、生命周期都由框架自动处理。特性传统方式FX 方式依赖顺序手动维护自动解析生命周期手写 start/stopfx.Hook 自动调度测试难度高(需真实依赖)低(接口易 mock)代码可读性分散在各处集中在 module 中错误提示运行时 panic启动时清晰报错对于中大型 Go 项目,FX 能显著降低代码耦合度,提升可测试性和可维护性。

ggaofengg的专栏 176

纯 Go 写的 JS 引擎,跑分超过了 C 语言的 QuickJS

moejs 是一个纯 Go 编写的高性能 JavaScript 运行时,专为 Go 程序中的插件沙箱场景设计。发布于 2026 年 11 月,由 new-api 维护者 Calcium-Ion 开发,相较 C 版 QuickJS 快 35%,内存占用仅 81 KiB,单次调用仅 6.9 微秒。支持快速复用运行时、零拷贝解析、安全沙箱与 TypeScript 直接编译,通过 test262 80971 个用例零失败。适合高并发插件系统,如 AI 网关钩子处理,已在实际场景中实现请求吞吐量提升 8.6 倍。仓库

前端之虎陈随易 256

Go + SQLite:database/sql 增删改查与事务

用 database/sql + 纯 Go SQLite 跑通 CRUD,讲连接池、事务、NULL、迁移与备份。

JudithHuang的博客 161

Tailscale 上手:把几台机器拼成一个局域网

一台每天背来背去的笔记本,一台家里的 Windows 台式,一台常年开着的 Linux 小主机,外加一台云上的 VPS。于是每次想在笔记本上连一次小主机,流程都是:回忆 IP → 发现变了 → 去路由器后台查 → 发现不在同一个网 → 打开某个穿透工具 → 折腾十分钟 → 干正事只要两分钟。Tailscale 解决的就是这一串前置动作。装完之后,上面这些机器在我眼里变成了四个稳定的名字,不管它们实际待在世界哪个网络里。

weixin_42357472的博客 240

每天10分钟学Go:第8课 映射(Map)

本文搭配可运行的完整示例代码,系统讲解 Go 语言 Map 的创建、增删改查、遍历等核心语法,整理了 maps 标准库用法与 8 个高频踩坑点,帮你快速掌握 Go 哈希表的正确使用方式。

2501_94567985的博客 222

rofbuf.go —— 单写单读无锁环形缓冲

该文详解 Go 运行时 profBuf 的无锁环形缓冲设计,解决信号处理器(无 g、不可分配)与用户 goroutine 间安全通信难题。通过原子操作、2的幂环长、打包索引(64位分三段)、溢出记录合并及 ABA 防护机制,实现高并发下低延迟、零锁的数据传递。核心创新在于计数运算三件套与溢出协议,确保在极端环境下仍能可靠捕获 CPU profile 事件。

不愿言弃-念何的博客 592

mprof.go(上)bucket 与栈哈希表

mprof.go 是 Go 运行时内存剖析的核心组件,负责采集 mallocgc、chansend 等操作的调用栈信息,构建基于哈希表与链表的三段式内存结构。其关键设计包括:使用 persistentalloc 分配不可被 GC 回收的内存以避免死锁;哈希表永不缩容,确保采样点可追溯;采用 3 周期轮转机制应对 malloc 与 free 时间不对齐问题。通过精细的锁分工(如 profInsertLock、profMemFutureLock)实现高并发下的安全更新与低延迟读取,最终将数据聚合为 /debug

不愿言弃-念何的博客 290
上一篇: Go-Zero框架上手前奏3: 深入理解 RPC 通信与 Go net/rpc 实践
下一篇: Go-Zero框架上手前奏5: 从原生 RPC 痛点深入 gRPC 的定义、安装与快速实践
Wang's Blog
博客等级 码龄12年 7438粉丝 2422原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Wang's Blog

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值