CODEWITHSUNDEEP
pythonpython-3.xmultithreadinggrpcgrpc-python
MichaelW
MichaelW

Reputation: 1464

Can I improve performance when using Python gRPC client stubs in more threads?

Lets say I have a Python gRPC server and a corresponding client.

According to this Question the same gRPC channel can be utilized to be passed to client stubs, each running in different threads.

Lets say RPC function foo() is called from thread T1 and the response takes about one second. Can I call foo() from thread T2 in the meantime, while T1 is still waiting for the response in thread or is the channel somehow locked until the first call returns? In other words: Is performance gained by using more threads, because the corresponding server is based on a thread pool and able to handle more requests "in parallel" and, if yes, should I use the same channel or different channels per thread?

EDIT: According to a quick test it seems that parallel requests using the same channel from different threads are possible and it gives sense, to do it in such way. However, because before closing the question, I would like to see a confirmation from an expert whether this code is correct:

import time
import threading
import grpc
import helloworld_pb2
import helloworld_pb2_grpc

def run_in_thread1(channel):

    n = 10000
    for i in range(n):
        stub = helloworld_pb2_grpc.GreeterStub(channel)
        response = stub.SayHello(helloworld_pb2.HelloRequest(name='1'))
        print("client 1: " + response.message)

    
def run_in_thread2(channel):

    n = 10000
    for i in range(n):
        stub = helloworld_pb2_grpc.GreeterStub(channel)
        response = stub.SayHello2(helloworld_pb2.HelloRequest(name='2'))
        print("client 2: " + response.message)

if __name__ == '__main__':
    print("I'm client")
    channel = grpc.insecure_channel('localhost:50051')
    x1 = threading.Thread(target=run_in_thread1, args=(channel,))
    x1.start()
    x2 = threading.Thread(target=run_in_thread2, args=(channel,))
    x2.start()
    
    x1.join()
    x2.join()

Upvotes: 2

Views: 2267

Answers (1)

Alexsandro Souza
Alexsandro Souza

Reputation: 995

gRPC uses HTTP/2 and can multiplex many requests on one connection and gRPC client connections should be re-used for the lifetime of the client app.

If you are inspired by what is done when working with databases, I would say you don't need to worry about it as the opening connection overhead doesn't exist when working with gRPC.

Upvotes: 2

Related Questions