import asyncio
import itertools
import threading
import time
 
 
class AsyncLoopThread:
    def __init__(self, name='no name'):
        self.thread = None
        self.name = name
        self._loop = None
 
    def run(self):
        """ spawn a new thread and run an event loop in it """
        if self.thread is None:
            self.thread = threading.Thread(target=lambda: asyncio.run(self._main_runner()))
            self.thread.start()
            return self.thread
        else:
            raise RuntimeError("thread already running")
 
    async def _main_runner(self):
        """ main asyncio task for event loop """
 
        # Сохраняем event loop в объекте, технической необходимости вызывать
        # get_running_loop нет, event loop на этот момент уже создан при вызове asyncio.run
        self._loop = asyncio.get_running_loop()
 
        # Этот объект-событие надо выставить, чтобы тормознуть цикл обработки
        # Так делать чуть более кошерно, чем loop.close(), можно корректно завершить разные задачи
        self._evt_exit = asyncio.Event()
        print(f"async-event-loop with name '{self.name}' started")
        # Эту задачу мы будем крутить в фоне, какая-то полезная активность
        async def _task():
            for counter in itertools.count():
                print(f"background async runner '{self.name}', counter: {counter}")
                await asyncio.sleep(0.5)
 
        bg_task = asyncio.create_task(_task())
        await self._evt_exit.wait()
        bg_task.cancel()
        print(f"task '{self.name}' received stop-event and will be closed")
 
 
    def add_task(self, coro):
        """ add task to event loop in another thread
 
        Метод для добавления задачи в цикл обработки сообщения из другого треда.
        Здесь важно, что если мы из другого треда хотим добавить задачу, то мы не 
        можем просто так вызвать loop.create_task()
        эта операция не сохраняет поток, как большинство других. Есть специальный 
        метод call_soon_threadsave для этих целен
        С помощью этого метота можно поместить какой-то синхронный коллбэк, не корутину, 
        в event loop. А уже в этом коллбэке мы можем добавить задачу-корутину в event loop
        """
        if self._loop:
            self._loop.call_soon_threadsafe(lambda: self._loop.create_task(coro))
 
def main():
    async_thread = AsyncLoopThread('async-thread')
    t = async_thread.run()
    time.sleep(3.3)
 
    print("Number of running threads: {}".format(threading.active_count()))
    print("main thread id: 0x{:016x}".format(threading.get_ident()))
 
    # main() исполняется в основном потоке, тогда как event loop в другомю
    # эту корутину мы поместим в другой поток, она что-то напечатает, поспит,
    # после чего остановит второй поток
    async def other_coro(obj):
        print("this coroutine is scheduled from the main thread, sleeping a little bit")
        print("event loop thread id: 0x{:016x}".format(threading.get_ident()))
        await asyncio.sleep(2)
        print("wake up and stop the event loop")
        obj._evt_exit.set()
 
    async_thread.add_task(other_coro(async_thread))
    print("coroutine was schedule in event loop thread")
 
    # Ждём, когда завершится тред с event loop
    t.join()
    print("all work done")
 
 
if __name__ == '__main__':
    main()
 

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