What is bidirectional streaming in gRPC and how does it work?

Expected Interview Answer

Step-by-Step Explanation

1. Step 1

   Declare the RPC

   In the .proto file, mark both the request and response with the stream keyword: rpc Chat(stream Msg) returns (stream Msg).

2. Step 2

   Generate code

   protoc produces a stub whose method returns a stream object that can both send and receive messages.

3. Step 3

   Open the stream

   The client calls the method, establishing a single long-lived HTTP/2 stream to the server.

4. Step 4

   Send and receive concurrently

   Each side runs independent read and write loops, sending messages whenever ready without blocking the other direction.

5. Step 5

   Half-close and finish

   When a side is done sending it closes its write half; the RPC completes once both directions finish and a status is returned.

Code Example

service ChatService {
  // stream on BOTH sides = bidirectional
  rpc Chat(stream ChatMessage) returns (stream ChatMessage);
}

message ChatMessage {
  string user = 1;
  string text = 2;
}

func (s *server) Chat(stream pb.ChatService_ChatServer) error {
  for {
    msg, err := stream.Recv()
    if err == io.EOF {
      return nil
    }
    if err != nil {
      return err
    }
    // echo back concurrently
    if err := stream.Send(&pb.ChatMessage{User: "server", Text: msg.Text}); err != nil {
      return err
    }
  }
}

Follow-up Questions

• How does HTTP/2 multiplexing enable bidirectional streaming?
• What is the difference between client, server and bidirectional streaming?
• How do you handle flow control and backpressure in a stream?
• How would you cancel or time out a long-lived stream?
• What happens when one side closes its half of the stream?