Improve readability

src/python/grpcio/grpc/_cython/_cygrpc/aio/completion_queue.pxd.pxi

@@ -23,7 +23,7 @@ cdef class PollerCompletionQueue(BaseCompletionQueue):
     cdef object _poller
     cdef object _poller_running
 
-    cdef _polling(self)
+    cdef void _poll(self) except *
 
 
 cdef class CallbackCompletionQueue(BaseCompletionQueue):

src/python/grpcio/grpc/_cython/_cygrpc/aio/completion_queue.pyx.pxi

@@ -36,11 +36,11 @@ cdef class PollerCompletionQueue(BaseCompletionQueue):
         self._shutdown_completed = asyncio.get_event_loop().create_future()
         self._poller = None
         self._poller_running = asyncio.get_event_loop().create_future()
-        self._poller = threading.Thread(target=self._polling_wrapper)
+        self._poller = threading.Thread(target=self._poll_wrapper)
         self._poller.daemon = True
         self._poller.start()
 
-    cdef _polling(self):
+    cdef void _poll(self) except *:
         cdef grpc_event event
         cdef CallbackContext *context
         cdef object waiter
@@ -53,7 +53,7 @@ cdef class PollerCompletionQueue(BaseCompletionQueue):
                                                 NULL)
 
             if event.type == GRPC_QUEUE_TIMEOUT:
-                raise NotImplementedError()
+                raise AssertionError("Core should not return timeout error!")
             elif event.type == GRPC_QUEUE_SHUTDOWN:
                 self._shutdown = True
                 grpc_call_soon_threadsafe(self._shutdown_completed.set_result, None)
@@ -64,8 +64,8 @@ cdef class PollerCompletionQueue(BaseCompletionQueue):
                     <CallbackWrapper>context.callback_wrapper,
                     event.success)
 
-    def _polling_wrapper(self):
+    def _poll_wrapper(self):
-        self._polling()
+        self._poll()
 
     async def shutdown(self):
         grpc_completion_queue_shutdown(self._cq)
@@ -103,4 +103,4 @@ cdef BaseCompletionQueue create_completion_queue():
     elif grpc_aio_engine is AsyncIOEngine.POLLER:
         return PollerCompletionQueue()
     else:
-        raise ValueError('Unexpected engine type [%s]' % grpc_aio_engine)
+        raise ValueError('Unsupported engine type [%s]' % grpc_aio_engine)

src/python/grpcio/grpc/_cython/_cygrpc/aio/grpc_aio.pyx.pxi

@@ -15,13 +15,14 @@
 
 cdef bint _grpc_aio_initialized = False
 # NOTE(lidiz) Theoretically, applications can run in multiple event loops as
-# long as they are in the same thread with same magic. However, I don't think
+# long as they are in the same thread with same magic. This is not a supported
-# we should support this use case. So, the gRPC Python Async Stack should use
+# use case. So, the gRPC Python Async Stack should use a single event loop
-# a single event loop picked by "init_grpc_aio".
+# picked by "init_grpc_aio".
-cdef object _grpc_aio_loop
+cdef object _grpc_aio_loop  # asyncio.AbstractEventLoop
-cdef object _event_loop_thread_ident
+cdef int64_t _event_loop_thread_ident
 cdef str _GRPC_ASYNCIO_ENGINE = os.environ.get('GRPC_ASYNCIO_ENGINE', 'default').lower()
 grpc_aio_engine = None
+cdef object _grpc_initialization_lock = threading.Lock()
 
 
 class AsyncIOEngine(enum.Enum):
@@ -36,6 +37,7 @@ def init_grpc_aio():
     global _event_loop_thread_ident
     global grpc_aio_engine
 
+    with _grpc_initialization_lock:
         # Marks this function as called
         if _grpc_aio_initialized:
             return
@@ -80,8 +82,6 @@ def init_grpc_aio():
             # library won't shutdown cleanly.
             grpc_init()
 
-    _grpc_aio_initialized = False
-
 
 def grpc_aio_loop():
     """Returns the one-and-only gRPC Aio event loop."""