@@ -9,4 +9,4 @@ cdef class Async:
         uv.uv_async_t *handle
         object callback
 
-    cdef send(self)
+    cdef void send(self)
@@ -20,7 +20,7 @@ cdef class Async:
     def __dealloc__(self):
         PyMem_Free(self.handle)
 
-    cdef send(self):
+    cdef void send(self):
         uv.uv_async_send(self.handle)
 
 
 
@@ -2,13 +2,15 @@
 
 
 from . cimport uv
+from .loop cimport Loop
 
 
 cdef class Idle:
     cdef:
         uv.uv_idle_t *handle
         object callback
         int running
+        Loop loop
 
-    cdef stop(self)
-    cdef start(self)
+    cdef void stop(self)
+    cdef void start(self)
@@ -18,24 +18,28 @@ cdef class Idle:
         uv.uv_idle_init(loop.loop, self.handle)
 
         self.running = 0
+        self.loop = loop
 
     def __dealloc__(self):
         try:
             self.stop()
         finally:
             PyMem_Free(self.handle)
 
-    cdef stop(self):
+    cdef void stop(self):
         if self.running == 1:
             uv.uv_idle_stop(self.handle)
             self.running = 0
 
-    cdef start(self):
+    cdef void start(self):
         if self.running == 0:
             uv.uv_idle_start(self.handle, cb_idle_callback)
             self.running = 1
 
 
 cdef void cb_idle_callback(uv.uv_idle_t* handle):
     cdef Idle idle = <Idle> handle.data
-    idle.callback()
+    try:
+        idle.callback()
+    except BaseException as ex:
+        idle.loop._handle_uvcb_exception(ex)
@@ -13,17 +13,23 @@ from libc.stdint cimport uint64_t
 cdef class Loop:
     cdef:
         uv.uv_loop_t *loop
-        int closed
+        int _closed
         int _debug
+        long _thread_id
+        int _running
+
+        object _ready
+        int _ready_len
 
         Async handler_async
         Idle handler_idle
         Signal handler_sigint
 
-        object last_error
-        object callbacks
-        object partial
-        object _default_task_constructor
+        object _last_error
+
+        object _make_partial
+        object _asyncio
+        object _asyncio_Task
 
         cdef object __weakref__
 
@@ -34,3 +40,8 @@ cdef class Loop:
 
     cdef _call_soon(self, object callback)
     cdef _call_later(self, uint64_t delay, object callback)
+
+    cdef _handle_uvcb_exception(self, object ex)
+
+    cdef _check_closed(self)
+    cdef _check_thread(self)
@@ -20,6 +20,7 @@ from libc.stdint cimport uint64_t
 
 from cpython.mem cimport PyMem_Malloc, PyMem_Free
 from cpython.exc cimport PyErr_CheckSignals, PyErr_Occurred
+from cpython.pythread cimport PyThread_get_thread_ident
 
 
 @cython.no_gc_clear
@@ -28,8 +29,10 @@ cdef class Loop:
         self.loop = <uv.uv_loop_t*> \
                             PyMem_Malloc(sizeof(uv.uv_loop_t))
         self.loop.data = <void*> self
-        self.closed = 0
+        self._closed = 0
         self._debug = 0
+        self._thread_id = 0
+        self._running = 0
 
         uv.uv_loop_init(self.loop)
 
@@ -39,8 +42,8 @@ cdef class Loop:
         # the policy won't be properly destroyed, hence the
         # loop won't be properly destroyed, hence some warnings
         # might not be shown at all.
-        asyncio = __import__('asyncio')
-        self._default_task_constructor = asyncio.Task
+        self._asyncio = __import__('asyncio')
+        self._asyncio_Task = self._asyncio.Task
 
     def __dealloc__(self):
         try:
@@ -56,80 +59,134 @@ cdef class Loop:
         self.handler_sigint = Signal(self, self._on_sigint, signal.SIGINT)
         self.handler_sigint.start()
 
-        self.last_error = None
+        self._last_error = None
 
-        self.callbacks = collections.deque()
+        self._ready = collections.deque()
+        self._ready_len = 0
 
-        self.partial = functools.partial
+        self._make_partial = functools.partial
 
     def _on_wake(self):
-        if len(self.callbacks) > 0:
+        if self._ready_len > 0 and not self.handler_idle.running:
             self.handler_idle.start()
 
     def _on_sigint(self):
-        self.last_error = KeyboardInterrupt()
+        self._last_error = KeyboardInterrupt()
         self._stop()
 
     def _on_idle(self):
         cdef int i, ntodo
-        cdef object popleft = self.callbacks.popleft
+        cdef object popleft = self._ready.popleft
 
-        ntodo = len(self.callbacks)
+        ntodo = len(self._ready)
         for i from 0 <= i < ntodo:
             handler = <Handle> popleft()
             if handler.cancelled == 0:
                 handler._run()
 
-        if len(self.callbacks) == 0:
+        self._ready_len = len(self._ready)
+        if self._ready_len == 0 and self.handler_idle.running:
             self.handler_idle.stop()
 
     cdef _stop(self):
         uv.uv_stop(self.loop)
 
     cdef _run(self, uv.uv_run_mode mode):
-        if self.closed:
+        if self._closed == 1:
             raise RuntimeError('unable to start the loop; it was closed')
 
+        if self._running == 1:
+            raise RuntimeError('Event loop is running.')
+
+        self._thread_id = PyThread_get_thread_ident()
+        self._running = 1
         uv.uv_run(self.loop, mode)
+        self._thread_id = 0
+        self._running = 0
 
-        if self.last_error is not None:
-            raise self.last_error
+        if self._last_error is not None:
+            last_error = self._last_error
+            self.close()
+            raise last_error
 
     cdef _close(self):
-        if self.closed == 0:
+        if self._running == 1:
+            raise RuntimeError("Cannot close a running event loop")
+        if self._closed == 0:
+            self._closed = 1
+
+            self._ready.clear()
+            self._ready_len = 0
+            self._last_error = None
+
             uv.uv_loop_close(self.loop)
-            self.closed = 1
 
     cdef uint64_t _time(self):
         return uv.uv_now(self.loop)
 
     cdef _call_soon(self, object callback):
         handle = Handle(self, callback)
-        self.callbacks.append(handle)
-        self.handler_idle.start()
+        self._ready.append(handle)
+        self._ready_len += 1;
+        if not self.handler_idle.running:
+            self.handler_idle.start()
         return handle
 
     cdef _call_later(self, uint64_t delay, object callback):
         return TimerHandle(self, callback, delay)
 
+    cdef _handle_uvcb_exception(self, object ex):
+        if isinstance(ex, Exception):
+            self.call_exception_handler({'exception': ex})
+        else:
+            # BaseException
+            self._last_error = ex
+            # Exit ASAP
+            self._stop()
+
+    cdef _check_closed(self):
+        if self._closed == 1:
+            raise RuntimeError('Event loop is closed')
+
+    cdef _check_thread(self):
+        if self._thread_id == 0:
+            return
+        cdef long thread_id = PyThread_get_thread_ident()
+        if thread_id != self._thread_id:
+            raise RuntimeError(
+                "Non-thread-safe operation invoked on an event loop other "
+                "than the current one")
+
     # Public API
 
+    def __repr__(self):
+        return ('<%s running=%s closed=%s debug=%s>'
+                % (self.__class__.__name__, self.is_running(),
+                   self.is_closed(), self.get_debug()))
+
     def call_soon(self, callback, *args):
+        self._check_closed()
+        if self._debug == 1:
+            self._check_thread()
         if len(args):
-            callback = self.partial(callback, *args)
+            callback = self._make_partial(callback, *args)
         return self._call_soon(callback)
 
     def call_soon_threadsafe(self, callback, *args):
+        self._check_closed()
         if len(args):
-            callback = self.partial(callback, *args)
+            callback = self._make_partial(callback, *args)
         handle = self._call_soon(callback)
         self.handler_async.send()
         return handle
 
     def call_later(self, delay, callback, *args):
+        self._check_closed()
+        if self._debug == 1:
+            self._check_thread()
         cdef uint64_t when = <uint64_t>(delay * 1000)
         if len(args):
-            callback = self.partial(callback, *args)
+            callback = self._make_partial(callback, *args)
         return self._call_later(when, callback)
 
     def time(self):
@@ -139,6 +196,7 @@ cdef class Loop:
         self._call_soon(lambda: self._stop())
 
     def run_forever(self):
+        self._check_closed()
         self._run(uv.UV_RUN_DEFAULT)
 
     def close(self):
@@ -156,11 +214,53 @@ cdef class Loop:
         else:
             self._debug = 0
 
+    def is_running(self):
+        if self._running == 0:
+            return False
+        else:
+            return True
+
+    def is_closed(self):
+        if self._closed == 0:
+            return False
+        else:
+            return True
+
     def create_task(self, coro):
-        return self._default_task_constructor(coro, loop=self)
+        self._check_closed()
+
+        return self._asyncio_Task(coro, loop=self)
+
+    def run_until_complete(self, future):
+        self._check_closed()
+
+        new_task = not isinstance(future, self._asyncio.Future)
+        future = self._asyncio.ensure_future(future, loop=self)
+        if new_task:
+            # An exception is raised if the future didn't complete, so there
+            # is no need to log the "destroy pending task" message
+            future._log_destroy_pending = False
+
+        done_cb = lambda fut: self.stop()
+
+        future.add_done_callback(done_cb)
+        try:
+            self.run_forever()
+        except:
+            if new_task and future.done() and not future.cancelled():
+                # The coroutine raised a BaseException. Consume the exception
+                # to not log a warning, the caller doesn't have access to the
+                # local task.
+                future.exception()
+            raise
+        future.remove_done_callback(done_cb)
+        if not future.done():
+            raise RuntimeError('Event loop stopped before Future completed.')
+
+        return future.result()
 
     def call_exception_handler(self, context):
-        print("!!! EXCEPTION HANDLER !!!", context)
+        print("!!! EXCEPTION HANDLER !!!", context, flush=True)
 
 
 @cython.internal
 
@@ -2,6 +2,7 @@
 
 
 from . cimport uv
+from .loop cimport Loop
 
 
 cdef class Signal:
@@ -10,6 +11,7 @@ cdef class Signal:
         object callback
         int running
         int signum
+        Loop loop
 
-    cdef stop(self)
-    cdef start(self)
+    cdef void stop(self)
+    cdef void start(self)