Go语言高并发与微服务实战专题精讲——远程过程调用 RPC——优化RPC调用，缓解频繁请求导致的GC压力

远程过程调用RPC——优化RPC调用, 缓解频繁请求导致的GC压力

  在Go语言的高并发和微服务架构中, 远程过程调用(RPC)是一种常用的通信机制。然而, 当频繁发送RPC请求时, 不断创建Request和Response结构体可能会带来额外的垃圾收集(GC)压力, 进而影响应用的性能和响应时间。为了减少这种GC压力, 可以采取以下几种策略:

    1. 对象池化(Object Pooling):
      对象池化是一种复用对象的技术, 可以避免频繁地创建和销毁对象。对于RPC请求和响应, 可以预先创建一个对象池, 当需要发送RPC请求时, 从池中获取一个已经初始化的Request对象, 使用完后再将其放回池中, 而不是直接丢弃。同样地, 对于响应对象也可以采用类似的方式。这样可以大大减少GC的压力。

    2. 使用缓存:
      如果RPC请求的参数或响应的数据具有可重用性, 可以考虑使用缓存来存储这些数据。例如, 对于经常发送的相同或类似的请求, 可以将请求参数缓存起来, 避免重复创建Request对象。同样地, 对于经常接收的响应数据, 也可以将其缓存起来, 减少Response对象的创建。

    3. 减少数据传输量:
      减少每次RPC请求和响应的数据传输量, 可以降低对象创建和内存分配的频率。可以通过压缩数据、只传输必要的数据字段、使用更紧凑的数据结构等方式来实现。这样不仅可以减少GC压力, 还可以提高网络传输效率。

    4. 优化序列化和反序列化:
      序列化和反序列化是RPC通信中不可避免的过程, 但也会对性能产生影响。选择高效的序列化和反序列化库, 如Protocol Buffers(Protobuf)或MessagePack等, 可以减少内存分配和对象创建的开销。此外, 还可以通过优化序列化格式、减少嵌套结构等方式来进一步提高性能。

    5. 调整GC参数:
      根据应用的实际情况, 可以调整Go语言的GC参数来优化性能。例如, 可以增加GC的触发阈值, 减少GC的频率；或者调整GC的并行度, 以适应不同的硬件环境和并发需求。需要注意的是, 调整GC参数可能会对整体性能产生复杂的影响, 因此应该谨慎进行, 并在实际环境中进行充分的测试。

 通过对象池化、使用缓存、减少数据传输量、优化序列化和反序列化以及调整GC参数等方式, 可以有效地减少频繁发送RPC请求时不断创建Request和Response结构体导致的GC压力, 从而提升应用的性能和响应时间。

一、对象池化

  下面代码实现了getRequest(), freeRequest(), getResponse(), 9和 freeResponse()方法，它们分别用于从对象池中获取和释放Request和Response对象。通过对象池化技术，可以减少频繁创建和销毁对象带来的垃圾收集压力，从而提高应用的性能和响应时间，源码如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
// Server represents an RPC Server. 
type Server struct { 
    serviceMap sync.Map   // 用于存储服务的映射关系，键为服务名，值为服务实例 
   
    reqLock    sync.Mutex // 保护freeReq的互斥锁 
    freeReq    *Request   // 指向可用的Request对象的指针，用于对象池化 
   
    respLock   sync.Mutex // 保护freeResp的互斥锁 
    freeResp   *Response  // 指向可用的Response对象的指针，用于对象池化 
} 
   
// Request is a header written before every RPC call. 
// 它是在每次RPC调用之前写入的头部信息。 
// 用于内部使用，但在此处记录以助于调试，例如当分析网络流量时。 
type Request struct { 
    ServiceMethod string   // 格式："Service.Method" 
    Seq           uint64   // 客户端选择的序列号 
    next          *Request // 用于Server中的空闲列表 
} 
   
// Response is a header written before every RPC return. 
// 它是在每次RPC返回之前写入的头部信息。 
// 用于内部使用，但在此处记录以助于调试，例如当分析网络流量时。 
type Response struct { 
    ServiceMethod string    // 回应请求的ServiceMethod 
    Seq           uint64    // 回应请求的序列号 
    Error         string    // 如果有的话，表示错误 
    next          *Response // 用于Server中的空闲列表 
} 
   
// getRequest从服务器的对象池中获取一个Request对象，如果池中没有可用对象，则新建一个。 
func (server *Server) getRequest() *Request { 
    server.reqLock.Lock()         // 加锁以保护共享资源freeReq 
    req := server.freeReq         // 从对象池中获取一个Request对象 
    if req == nil { 
        req = new(Request) // 如果对象池为空，则新建一个Request对象 
    } else { 
        server.freeReq = req.next // 更新对象池的头部为下一个可用的Request对象 
        *req = Request{}          // 重置Request对象的属性，以便重新使用 
    } 
    server.reqLock.Unlock() // 解锁，以允许其他goroutine访问freeReq 
    return req              // 返回获取到的Request对象 
} 
   
// freeRequest将使用完的Request对象放回服务器的对象池，以供后续复用。 
func (server *Server) freeRequest(req *Request) { 
    server.reqLock.Lock()        // 加锁以保护共享资源freeReq 
    req.next = server.freeReq    // 将当前Request对象添加到对象池的头部 
    server.freeReq = req         // 更新对象池的头部为当前Request对象 
    server.reqLock.Unlock()      // 解锁，以允许其他goroutine访问freeReq 
} 
   
// getResponse从服务器的对象池中获取一个Response对象，如果对象池中没有可用对象，则新建一个。 
func (server *Server) getResponse() *Response { 
    server.respLock.Lock()          // 加锁以保护共享资源freeResp 
    resp := server.freeResp         // 从对象池中获取一个Response对象 
    if resp == nil { 
        resp = new(Response) // 如果对象池为空，则新建一个Response对象 
    } else { 
        server.freeResp = resp.next // 更新对象池的头部为下一个可用的Response对象 
        *resp = Response{}          // 重置Response对象的属性，以便重新使用 
    } 
    server.respLock.Unlock() // 解锁，以允许其他goroutine访问freeResp 
    return resp              // 返回获取到的Response对象 
} 
   
// freeResponse将使用完的Response对象放回服务器的对象池，以供后续复用。 
func (server *Server) freeResponse(resp *Response) { 
    server.respLock.Lock()         // 加锁以保护共享资源freeResp 
    resp.next = server.freeResp    // 将当前Response对象添加到对象池的头部 
    server.freeResp = resp         // 更新对象池的头部为当前Response对象 
    server.respLock.Unlock()       // 解锁，以允许其他goroutine访问freeResp 
}　 

二、缓存

代码主要定义了一个RPC（远程过程调用）服务器的框架，并对该框架进行了扩展，加入了LRU（最近最少使用）缓存机制以提高性能。以下是代码的详细说明总结：

    • 基础RPC框架：

      • Request和Response结构体分别定义了RPC请求和响应的头部信息。这些信息在RPC调用和返回时都会使用，主要用于调试和网络流量分析。
      • Server结构体代表了一个RPC服务器，其中包含一个服务映射表（serviceMap），用于存储和查找已注册的服务。

    • LRU缓存机制：

      • LRUCache结构体实现了一个简单的LRU缓存。它使用一个哈希表（cache）和一个双向链表（list）来维护缓存条目。哈希表提供快速的键查找，而双向链表则用于按访问顺序排列条目。
      • listNode结构体表示双向链表中的一个节点，包含键、值以及指向前一个和后一个节点的指针。
      • DoublyLinkedList结构体表示双向链表，具有头部和尾部指针。
      • NewLRUCache函数用于创建一个新的LRU缓存实例。
      • Get和Put方法分别用于从缓存中获取和添加值。Get方法在找到键时会更新节点在链表中的位置，以表示该节点最近被访问过。Put方法在添加新值时，如果缓存已满，会移除最久未使用的条目（即链表尾部的节点）。

    • 扩展的RPC服务器：

      • 在原始的Server结构体中加入了两个LRU缓存（reqCache和respCache），分别用于缓存请求和响应。
      • 还加入了四个命中率计数器（hitCountReq, missCountReq, hitCountResp, missCountResp），用于跟踪请求和响应缓存的命中情况。
      • NewServer函数用于创建一个新的、带有LRU缓存和命中率计数器的RPC服务器实例。

    • 待实现的功能：

      • 代码注释中提到，getRequest和getResponse方法需要更新以使用LRU缓存和更新命中率计数器。这意味着在实际的请求处理过程中，应该首先检查请求或响应是否已经在缓存中，如果在，则直接从缓存中获取，并更新命中率计数器；如果不在，则进行正常的处理流程，并将结果添加到缓存中。

通过引入LRU缓存机制，旨在提高RPC服务器的性能，减少不必要的计算和网络传输开销。同时，通过命中率计数器，可以监控缓存的使用情况，为进一步优化提供依据。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
// Request is a header written before every RPC call. It is used internally
// but documented here as an aid to debugging, such as when analyzing
// network traffic.
type Request struct {
    ServiceMethod string   // format: "Service.Method"
    Seq           uint64   // sequence number chosen by client
    next          *Request // for free list in Server
}
 
// Response is a header written before every RPC return. It is used internally
// but documented here as an aid to debugging, such as when analyzing
// network traffic.
type Response struct {
    ServiceMethod string    // echoes that of the Request
    Seq           uint64    // echoes that of the request
    Error         string    // error, if any.
    next          *Response // for free list in Server
}
 
// Server represents an RPC Server.
type Server struct {
    serviceMap sync.Map   // map[string]*service
    reqLock    sync.Mutex // protects freeReq
    freeReq    *Request
    respLock   sync.Mutex // protects freeResp
    freeResp   *Response
}
// LRUCache 实现了一个简单的LRU缓存 
type LRUCache struct { 
    capacity int 
    cache    map[string]*listNode 
    list     *DoublyLinkedList 
    lock     sync.Mutex 
} 
   
type listNode struct { 
    key   string 
    value interface{} 
    prev  *listNode 
    next  *listNode 
} 
   
type DoublyLinkedList struct { 
    head *listNode 
    tail *listNode 
} 
   
// NewLRUCache 创建一个新的LRU缓存实例 
func NewLRUCache(capacity int) *LRUCache { 
    return &LRUCache{ 
        capacity: capacity, 
        cache:    make(map[string]*listNode), 
        list:     &DoublyLinkedList{}, 
    } 
} 
   
// Get 从缓存中获取一个值，如果值存在，则更新其在LRU列表中的位置 
func (c *LRUCache) Get(key string) (interface{}, bool) { 
    c.lock.Lock() 
    defer c.lock.Unlock() 
   
    if node, ok := c.cache[key]; ok { 
        c.list.remove(node) 
        c.list.addToHead(node) 
        return node.value, true 
    } 
    return nil, false 
} 
   
// Put 向缓存中添加一个值，如果缓存已满，则移除最久未使用的条目 
func (c *LRUCache) Put(key string, value interface{}) { 
    c.lock.Lock() 
    defer c.lock.Unlock() 
   
    if _, ok := c.cache[key]; ok { 
        c.cache[key].value = value 
        c.list.remove(c.cache[key]) 
        c.list.addToHead(c.cache[key]) 
        return 
    } 
   
    newNode := &listNode{key: key, value: value} 
    if len(c.cache) >= c.capacity { 
        oldest := c.list.tail 
        if oldest != nil { 
            delete(c.cache, oldest.key) 
            c.list.remove(oldest) 
        } 
    } 
    c.cache[key] = newNode 
    c.list.addToHead(newNode) 
} 
   
// ... [DoublyLinkedList 的实现省略，包括 addToHead, remove 等方法] ... 
   
// Server 结构现在包含LRU缓存和命中率计数器 
type Server struct { 
    serviceMap   sync.Map 
    reqCache     *LRUCache 
    respCache    *LRUCache 
    reqLock      sync.Mutex 
    respLock     sync.Mutex 
    hitCountReq  int64 // 请求缓存命中次数 
    missCountReq int64 // 请求缓存未命中次数 
    hitCountResp int64 // 响应缓存命中次数 
    missCountResp int64 // 响应缓存未命中次数 
} 
   
// NewServer 初始化并返回一个新的RPC服务器实例，包括初始化的LRU缓存和命中率计数器 
func NewServer(cacheCapacity int) *Server { 
    return &Server{ 
        reqCache:   NewLRUCache(cacheCapacity), 
        respCache:  NewLRUCache(cacheCapacity), 
        serviceMap: sync.Map{}, 
    } 
} 
   
// getRequest 和 getResponse 方法需要更新以使用LRU缓存和更新命中率计数器 
// ... [getRequest 和 getResponse 方法的实现省略，需要更新以使用LRUCache的Get和Put方法，并更新命中率计数器] ...
posted @   左扬  阅读(64)  评论(0)  编辑  收藏  举报
相关博文：
· Go语言高并发与微服务实战专题精讲——远程过程调用 RPC——实践案例：Go 语言 RPC 过程调用实践
· Go语言高并发与微服务实战专题精讲——远程过程调用 RPC——高性能的 gRPC（实践案例）
· Go微服务框架-1.RPC简介及原理介绍
· Go RPC开发简介
· go rpc
阅读排行：
· 阿里最新开源QwQ-32B，效果媲美deepseek-r1满血版，部署成本又又又降低了！
· 开源Multi-agent AI智能体框架aevatar.ai，欢迎大家贡献代码
· Manus重磅发布：全球首款通用AI代理技术深度解析与实战指南
· 被坑几百块钱后，我竟然真的恢复了删除的微信聊天记录！
· AI技术革命，工作效率10个最佳AI工具
levels of contents
点击右上角即可分享
微信分享提示
AI IDE Trae