How does gRPC handle requests from the same client concurrently? - go

Question

I was reading gRPC tutorial (https://grpc.io/docs/languages/go/basics/#bidirectional-streaming-rpc) and found the following code:
1 func (s *routeGuideServer) RouteChat(stream pb.RouteGuide_RouteChatServer) error {
2 for {
3 in, err := stream.Recv()
4 if err == io.EOF {
5 return nil
6 }
7 if err != nil {
8 return err
9 }
10 key := serialize(in.Location)
11 ... // look for notes to be sent to client
12 for _, note := range s.routeNotes[key] {
13 if err := stream.Send(note); err != nil {
14 return err
15 }
16 }
17 }
18 }
My current understanding from reading the code is that, when a request A from client is received in line 3, server proceeds to line 4 - 16 to handle that request, and this is a blocking process. If the client sends request B immediately after A is sent, the server cannot receive and handle it until request A is done processing.
So if processing A takes a very long time and B is a request to stop processing A, then the code will need to first finish processing A before starting to stop processing it, which is weird. I thought the code in this case should be something like:
1 func (s *routeGuideServer) RouteChat(stream pb.RouteGuide_RouteChatServer) error {
2 for {
3 in, err := stream.Recv()
4 if err == io.EOF {
5 return nil
6 }
7 if err != nil {
8 return err
9 }
10 if GetTypeofRequest(in) == A {
11 go HandleRequestA(stream)
12 } else if GetTypeofRequest(in) == B {
13 go HandleRequestB(stream)
14 }
15 }
16 }
Then in HandleRequestA and HandleRequestB, stream sends different responses.
I was under the impression that gRPC should recv and handle requests concurrently and doesn't require such goroutines. Please correct me if I'm wrong.