手撸golang GO与微服务 net.rpc之1

原创
03/24 23:46
阅读数 88

手撸golang GO与微服务 net.rpc

缘起

最近阅读 [Go微服务实战] (刘金亮, 2021.1) 本系列笔记拟采用golang练习之 gitee: https://gitee.com/ioly/learning.gooop

net/rpc

微服务中的进程间通信概述
对于进程间通信的技术,开发者有多种选择。
可以选择基于同步通信的通信机制,比如HTTP RESTful;
也可以选择基于异步通信的方式,Go语言提供了标准的net/rpc包以支持异步。

远程过程调用协议(Remote Procedure Call Protocol, RPC),
是一种通过网络从远程计算机程序上请求服务,
而不需要了解底层网络技术的协议。

目标

  • 使用net/rpc包写个时间请求rpc, 并测试并发性能.

设计

  • TimeServer: 时间服务端, 将自身注册到rpc, 并提供GetTime服务
  • TimeClient: 连接到时间服务器, 并远程调用GetTime服务。短连接模式,即总是在rpc调用后立即断开连接。

单元测试

net_rpc_test.go, 分别并发创建100/300/500/1000个时间客户端, 向服务器请求时间, 并统计失败次数和平均耗时

package net_rpc

import (
	"learning/gooop/net_rpc"
	"sync"
	"testing"
	"time"
)

func fnAssertTrue(t *testing.T, b bool, msg string) {
	if !b {
		t.Fatal(msg)
	}
}

type CallLog struct {
	done bool
	cost int64
}

func Test_NetRPC(t *testing.T) {
	server := new(net_rpc.TimeServer)
	err := server.Serve(3333)
	if err != nil {
		t.Fatal(err)
	}
	time.Sleep(100 * time.Millisecond)

	fnTestRpcCall := func(log *CallLog) {
		c := net_rpc.NewTimeClient("localhost:3333")

		t0 := time.Now().UnixNano()
		err, ret := c.GetTime()
		log.cost = time.Now().UnixNano() - t0
		log.done = err == nil

		if log.done {
			fnAssertTrue(t, ret > 0, "expecting ret>0")
		}
	}

	fnTestConcurrency := func(threads int) {
		logs := make([]*CallLog, threads)
		var g sync.WaitGroup

		for i, _ := range logs {
			logs[i] = new(CallLog)
			n := i

			g.Add(1)
			go func() {
				fnTestRpcCall(logs[n])
				g.Done()
			}()
		}

		g.Wait()

		var failed, max, avg int64 = 0, 0, 0
		for _, it := range logs {
			if !it.done {
				failed++
			}

			if it.cost > max {
				max = it.cost
			}

			avg += it.cost
		}
		avg = avg / int64(threads)

		maxf := float64(max) / float64(time.Millisecond/time.Nanosecond)
		avgf := float64(avg) / float64(time.Millisecond/time.Nanosecond)
		t.Logf("threads=%d, failed=%d, max=%fms, avg=%fms", threads, failed, maxf, avgf)
	}

	fnTestConcurrency(100)
	fnTestConcurrency(300)
	fnTestConcurrency(500)
	fnTestConcurrency(1000)
}

测试输出

脚趾头告诉我, 时间都花在net.dial上面了

$ go test -v net_rpc_test.go 
=== RUN   Test_NetRPC
2021/03/24 23:55:21 rpc.Register: method "Serve" has 2 input parameters; needs exactly three
    net_rpc_test.go:75: threads=100, failed=0, max=50.962322ms, avg=42.961170ms
    net_rpc_test.go:75: threads=300, failed=0, max=45.608988ms, avg=30.233982ms
    net_rpc_test.go:75: threads=500, failed=0, max=99.810739ms, avg=81.164639ms
    net_rpc_test.go:75: threads=1000, failed=0, max=359.049068ms, avg=185.030143ms
--- PASS: Test_NetRPC (0.66s)
PASS
ok      command-line-arguments  0.666s

TimeServer.go

时间服务端, 将自身注册到rpc, 并提供GetTime服务

package net_rpc

import (
	"fmt"
	"net"
	"net/rpc"
	"time"
)

type TimeServer int

func (me *TimeServer) GetTime(_ int, t *int64) error {
	*t = time.Now().UnixNano()
	return nil
}

func (me *TimeServer) Serve(port int) error {
	addy, err := net.ResolveTCPAddr("tcp", fmt.Sprintf("0.0.0.0:%d", port))
	if err != nil {
		return err
	}

	err = rpc.Register(me)
	if err != nil {
		return err
	}

	inbound, err := net.ListenTCP("tcp", addy)
	if err != nil {
		return err
	}
	go rpc.Accept(inbound)
	return nil
}

TimeClient.go

连接到时间服务器, 并远程调用GetTime服务。短连接模式,即总是在rpc调用后立即断开连接。

package net_rpc

import "net/rpc"

type TimeClient struct {
	serverAddress string
}


func NewTimeClient(serverAddress string) *TimeClient {
	it := new(TimeClient)
	it.init(serverAddress)
	return it
}

func (me *TimeClient) init(serverAddress string) {
	me.serverAddress = serverAddress
}

func (me *TimeClient) GetTime() (error, int64) {
	client, err := rpc.Dial("tcp", me.serverAddress)
	if err != nil {
		return err, 0
	}
	defer client.Close()

	var t int64 = 0
	err = client.Call("TimeServer.GetTime", 1, &t)
	if err != nil {
		return err, 0
	}

	return nil, t
}

(end)

展开阅读全文
打赏
0
0 收藏
分享
加载中
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部