Golang搭建jsonRPC服务器，Python客户端高并发10000组请求压力测试

Golang原生支持多线程（协程），所以处理高并发有非常优异的性能表现，非常适合用来搭建服务器。

这里用Golang搭建jsonRPC服务器，Python客户端高并发10000组请求压力测试

Golang jsonRPC服务器：

package main

import (
   "net"
   "net/rpc"
   "net/rpc/jsonrpc"
   "strings"
)

type MyFunc struct {
}

func (self MyFunc) DoSomething(p []string, reply *string) error {
   *reply = strings.Join(p, ", ")
   return nil
}

func main() {
   server := rpc.NewServer()
   server.RegisterName("Do", new(MyFunc))

   listener, _ := net.Listen("tcp", "127.0.0.1:10001")
   defer listener.Close()

   for {
      conn, _ := listener.Accept()
      defer conn.Close()
      //rpc.ServeConn(conn)
      go server.ServeCodec(jsonrpc.NewServerCodec(conn))
   }
}

Python jsonRPC客户端

import json
import socket
import time
from threading import Thread

class RPCClient():
    def __init__(self, addr):
        self.socket = socket.create_connection(addr)
        self.id = 0

    def message(self, name, *params):
        self.id += 1
        return dict(id=self.id, params=list(params), method=name)

    def call(self, name, *params):
        req = self.message(name, *params)
        id = req.get('id')

        mesg = json.dumps(req)
        self.socket.sendall(mesg.encode())

        resp = self.socket.recv(4096)
        resp = json.loads(resp.decode())

        return resp

    def close(self):
        self.socket.close()

def call(names):
    rpc = RPCClient(("127.0.0.1", 10001))
    rpc.call("Do.DoSomething", list(names))


start = time.time()
for _ in range(10000):
    t = Thread(target=call, args=(("Tom", "Jerry"),))
    t.daemon = True
    t.start()
print("10000组jsonRPC高并发请求，用时", time.time()-start, "秒")

测试结果：

10000组jsonRPC高并发请求，用时 1.7656581401824951 秒

Golang的服务器响应还是非常令人满意的