code: public static <ReqT, RespT> RespT blockingUnaryCall(
        Channel channel, MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, ReqT req) {
      ThreadlessExecutor executor = new ThreadlessExecutor();
      ClientCall<ReqT, RespT> call = channel.newCall(method, callOptions.withExecutor(executor));
      try {
        ListenableFuture<RespT> responseFuture = futureUnaryCall(call, req);
        while (!responseFuture.isDone()) {
          try {
            executor.waitAndDrain();
          } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw Status.CANCELLED
                .withDescription("Call was interrupted")
                .withCause(e)
                .asRuntimeException();
          }
        }
        return getUnchecked(responseFuture);
      } catch (RuntimeException e) {
        throw cancelThrow(call, e);
      } catch (Error e) {
        throw cancelThrow(call, e);
      }
    }
docs: Executes a unary call and blocks on the response.  The {@code call} should not be already
  started.  After calling this method, {@code call} should no longer be used.
  
  @return the single response message.