asynchronous IO.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Coroutine"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def A():\n",
    "    print('1')\n",
    "    print('2')\n",
    "    print('3')\n",
    "def B():\n",
    "    print('x')\n",
    "    print('y')\n",
    "    print('z')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "generator "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def consumer():\n",
    "    r=''\n",
    "    while True:\n",
    "        n=yield r \n",
    "        if not n:\n",
    "            return\n",
    "        print('[CONSUMER] Consuming %s...' %n)\n",
    "        r='200 OK'\n",
    "def produce(c):\n",
    "    c.send(None)\n",
    "    n=0\n",
    "    while n<5:\n",
    "        n=n+1 \n",
    "        print('[PRODUCER] Producing %s...' %n)\n",
    "        r=c.send(n)\n",
    "        print('[PRODUCER] Consumer return: %s' % r)\n",
    "    c.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[PRODUCER] Producing 1...\n",
      "[CONSUMER] Consuming 1...\n",
      "[PRODUCER] Consumer return: 200 OK\n",
      "[PRODUCER] Producing 2...\n",
      "[CONSUMER] Consuming 2...\n",
      "[PRODUCER] Consumer return: 200 OK\n",
      "[PRODUCER] Producing 3...\n",
      "[CONSUMER] Consuming 3...\n",
      "[PRODUCER] Consumer return: 200 OK\n",
      "[PRODUCER] Producing 4...\n",
      "[CONSUMER] Consuming 4...\n",
      "[PRODUCER] Consumer return: 200 OK\n",
      "[PRODUCER] Producing 5...\n",
      "[CONSUMER] Consuming 5...\n",
      "[PRODUCER] Consumer return: 200 OK\n"
     ]
    }
   ],
   "source": [
    "c=consumer()\n",
    "produce(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# asyncio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import asyncio\n",
    "\n",
    "@asyncio.coroutine\n",
    "def hello():\n",
    "    print(\"hello world!\")\n",
    "    r= yield from asyncio.sleep(1)\n",
    "    print(\"hello again!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "loop = asyncio.get_event_loop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world!\n",
      "hello again!\n"
     ]
    }
   ],
   "source": [
    "loop.run_until_complete(hello())\n",
    "loop.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world! (<_MainThread(MainThread, started 13960)>)\n",
      "Hello world! (<_MainThread(MainThread, started 13960)>)\n",
      "Hello again! (<_MainThread(MainThread, started 13960)>)\n",
      "Hello again! (<_MainThread(MainThread, started 13960)>)\n"
     ]
    }
   ],
   "source": [
    "import threading\n",
    "import asyncio\n",
    "\n",
    "@asyncio.coroutine\n",
    "def hello():\n",
    "    print('Hello world! (%s)' % threading.currentThread())\n",
    "    yield from asyncio.sleep(1)\n",
    "    print('Hello again! (%s)' % threading.currentThread())\n",
    "\n",
    "loop2 = asyncio.get_event_loop()\n",
    "tasks=[hello(),hello()]\n",
    "loop2.run_until_complete(asyncio.wait(tasks))\n",
    "loop2.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import asyncio\n",
    "@asyncio.coroutine\n",
    "def wget(host):\n",
    "    print('wget %s...' % host)\n",
    "    connect=asyncio.open_connection(host,80)\n",
    "    reader,writer=yield from connect\n",
    "    header='GET / HTTP/1.0\\r\\nHost: %s\\r\\n\\r\\n' % host\n",
    "    writer.write(header.encode('utf-8'))\n",
    "    yield from writer.drain()\n",
    "    while True:\n",
    "        line = yield from reader.readline()\n",
    "        if line == b'\\r\\n':\n",
    "            break\n",
    "        print('%s header > %s' % (host,line.decode('utf-8').rstrip()))\n",
    "    writer.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "loop=asyncio.get_event_loop()\n",
    "tasks=[wget(host) for host in ['www.sina.com.cn','www.sohu.com','www.163.com']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wget www.sina.com.cn...\n",
      "wget www.163.com...\n",
      "wget www.sohu.com...\n",
      "www.sina.com.cn header > HTTP/1.1 302 Moved Temporarily\n",
      "www.sina.com.cn header > Server: nginx\n",
      "www.sina.com.cn header > Date: Sat, 23 Feb 2019 05:57:52 GMT\n",
      "www.sina.com.cn header > Content-Type: text/html\n",
      "www.sina.com.cn header > Content-Length: 154\n",
      "www.sina.com.cn header > Connection: close\n",
      "www.sina.com.cn header > Location: https://www.sina.com.cn/\n",
      "www.sina.com.cn header > X-Via-CDN: f=edge,s=cern.beijing.ha2ts4.211.nb.sinaedge.com,c=2001:da8:8001:833:54db:62d6:9115:4ed2;\n",
      "www.sina.com.cn header > X-Via-Edge: 155090147294700541591410011021eabd476\n",
      "www.sohu.com header > HTTP/1.1 200 OK\n",
      "www.sohu.com header > Content-Type: text/html;charset=UTF-8\n",
      "www.sohu.com header > Connection: close\n",
      "www.sohu.com header > Server: nginx\n",
      "www.sohu.com header > Date: Sat, 23 Feb 2019 05:57:29 GMT\n",
      "www.sohu.com header > Cache-Control: max-age=60\n",
      "www.sohu.com header > X-From-Sohu: X-SRC-Cached\n",
      "www.sohu.com header > Content-Encoding: gzip\n",
      "www.sohu.com header > FSS-Cache: HIT from 9855973.18375663.10534247\n",
      "www.sohu.com header > FSS-Proxy: Powered by 2450292.3564414.3128453\n",
      "www.163.com header > HTTP/1.0 302 Moved Temporarily\n",
      "www.163.com header > Server: Cdn Cache Server V2.0\n",
      "www.163.com header > Date: Sat, 23 Feb 2019 05:57:53 GMT\n",
      "www.163.com header > Content-Length: 0\n",
      "www.163.com header > Location: http://www.163.com/special/0077jt/error_isp.html\n",
      "www.163.com header > X-Via: 1.0 taidianxin122:10 (Cdn Cache Server V2.0)\n",
      "www.163.com header > Connection: close\n"
     ]
    }
   ],
   "source": [
    "loop.run_until_complete(asyncio.wait(tasks))\n",
    "loop.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# async/await"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "@asyncio.coroutine ->> async;\n",
    "\n",
    "yield from ->> await"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wget www.sina.com.cn...\n",
      "wget www.sohu.com...\n",
      "wget www.163.com...\n",
      "www.sina.com.cn header > HTTP/1.1 302 Moved Temporarily\n",
      "www.sina.com.cn header > Server: nginx\n",
      "www.sina.com.cn header > Date: Sat, 23 Feb 2019 06:04:08 GMT\n",
      "www.sina.com.cn header > Content-Type: text/html\n",
      "www.sina.com.cn header > Content-Length: 154\n",
      "www.sina.com.cn header > Connection: close\n",
      "www.sina.com.cn header > Location: https://www.sina.com.cn/\n",
      "www.sina.com.cn header > X-Via-CDN: f=edge,s=cern.beijing.ha2ts4.206.nb.sinaedge.com,c=2001:da8:8001:833:54db:62d6:9115:4ed2;\n",
      "www.sina.com.cn header > X-Via-Edge: 1550901848898005415914100060277f539b2\n",
      "www.sohu.com header > HTTP/1.1 200 OK\n",
      "www.sohu.com header > Content-Type: text/html;charset=UTF-8\n",
      "www.sohu.com header > Connection: close\n",
      "www.sohu.com header > Server: nginx\n",
      "www.sohu.com header > Date: Sat, 23 Feb 2019 06:03:35 GMT\n",
      "www.sohu.com header > Cache-Control: max-age=60\n",
      "www.sohu.com header > X-From-Sohu: X-SRC-Cached\n",
      "www.sohu.com header > Content-Encoding: gzip\n",
      "www.sohu.com header > FSS-Cache: HIT from 9855973.18375663.10534247\n",
      "www.sohu.com header > FSS-Proxy: Powered by 2384755.3433341.3062915\n",
      "www.163.com header > HTTP/1.0 302 Moved Temporarily\n",
      "www.163.com header > Server: Cdn Cache Server V2.0\n",
      "www.163.com header > Date: Sat, 23 Feb 2019 06:04:09 GMT\n",
      "www.163.com header > Content-Length: 0\n",
      "www.163.com header > Location: http://www.163.com/special/0077jt/error_isp.html\n",
      "www.163.com header > X-Via: 1.0 taidianxin122:10 (Cdn Cache Server V2.0)\n",
      "www.163.com header > Connection: close\n"
     ]
    }
   ],
   "source": [
    "import asyncio\n",
    "async def wget(host):\n",
    "    print('wget %s...' % host)\n",
    "    connect=asyncio.open_connection(host,80)\n",
    "    reader,writer=await connect\n",
    "    header='GET / HTTP/1.0\\r\\nHost: %s\\r\\n\\r\\n' % host\n",
    "    writer.write(header.encode('utf-8'))\n",
    "    await writer.drain()\n",
    "    while True:\n",
    "        line = await reader.readline()\n",
    "        if line == b'\\r\\n':\n",
    "            break\n",
    "        print('%s header > %s' % (host,line.decode('utf-8').rstrip()))\n",
    "    writer.close()\n",
    "\n",
    "loop=asyncio.get_event_loop()\n",
    "tasks=[wget(host) for host in ['www.sina.com.cn','www.sohu.com','www.163.com']]\n",
    "\n",
    "loop.run_until_complete(asyncio.wait(tasks))\n",
    "loop.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import asyncio\n",
    "import time\n",
    "\n",
    "async def say_after(delay,what):\n",
    "    await asyncio.sleep(delay)\n",
    "    print(what)\n",
    "    \n",
    "async def main():\n",
    "    print(f\"started at {time.strftime('%X')}\")\n",
    "    await say_after(1,'hello')\n",
    "    await say_after(2,'world')\n",
    "    print(f\"finished at {time.strftime('%X')}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "started at 08:55:28\n",
      "hello\n",
      "world\n",
      "finished at 08:55:31\n"
     ]
    }
   ],
   "source": [
    "if __name__=='__main__':\n",
    "    loop=asyncio.get_event_loop()\n",
    "    loop.run_until_complete(main())\n",
    "    loop.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Awaitables Object"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Coroutines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:4: RuntimeWarning: coroutine 'nested' was never awaited\n",
      "  after removing the cwd from sys.path.\n"
     ]
    }
   ],
   "source": [
    "async def nested():\n",
    "    return 42 \n",
    "async def main():\n",
    "    nested()\n",
    "    print(await nested())\n",
    "loop=asyncio.new_event_loop()\n",
    "asyncio.set_event_loop(loop)\n",
    "loop.run_until_complete(main())\n",
    "loop.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*nested()* will not run because it's not *__awaited__*, but *_await_ nested()* will print __42__."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tasks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<Task pending coro=<nested() running at <ipython-input-22-73d8e0000cbf>:1>>\n",
      "waiting 2s\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "async def nested():\n",
    "    await asyncio.sleep(2)\n",
    "    print(\"waiting 2s\")\n",
    "async def main():\n",
    "    task=asyncio.ensure_future(nested())\n",
    "    print(task)\n",
    "    await task\n",
    "    print(task.done())\n",
    "if __name__=='__main__':\n",
    "    loop=asyncio.new_event_loop()\n",
    "    asyncio.set_event_loop(loop)\n",
    "    try:\n",
    "        loop.run_until_complete(main())\n",
    "    except KeyboardInterrupt as e:\n",
    "        for task in asyncio.Task.all_tasks():\n",
    "            print(task)\n",
    "            task.cancel()\n",
    "            print(task)\n",
    "        loop.run_forever()\n",
    "    finally:\n",
    "        loop.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Future"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Gather tasks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## asyncio.gather"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "async def factorial(name,number):\n",
    "    f=1 \n",
    "    for i in range(2,number+1):\n",
    "        print(f\"Task {name}: Compute factorial({i})...\")\n",
    "        if number == 2:\n",
    "            1/0\n",
    "        await asyncio.sleep(1)\n",
    "        f *= i \n",
    "    print(f\"Task {name}: factorial({number}) = {f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "async def main():\n",
    "    res = await asyncio.gather(\n",
    "    *[factorial(\"A\",2),\n",
    "     factorial(\"B\",3),\n",
    "     factorial(\"C\",4)],\n",
    "    return_exceptions=True)\n",
    "    for item in res:\n",
    "        print(item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Task B: Compute factorial(2)...\n",
      "Task C: Compute factorial(2)...\n",
      "Task A: Compute factorial(2)...\n",
      "Task B: Compute factorial(3)...\n",
      "Task C: Compute factorial(3)...\n",
      "Task B: factorial(3) = 6\n",
      "Task C: Compute factorial(4)...\n",
      "Task C: factorial(4) = 24\n",
      "division by zero\n",
      "None\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "loop=asyncio.new_event_loop()\n",
    "asyncio.set_event_loop(loop)\n",
    "try:\n",
    "    loop.run_until_complete(main())\n",
    "except KeyboardInterrupt as e: \n",
    "    for task in asyncio.Task.all_tasks():\n",
    "        print(task)\n",
    "        task.cancel()\n",
    "        print(task)\n",
    "    loop.run_forever()\n",
    "finally:\n",
    "    loop.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## asyncio.wait"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Timeouts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "asyncio.wait_for()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "asyncio.wait_for()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "timeout!\n"
     ]
    }
   ],
   "source": [
    "async def eternity():\n",
    "    await asyncio.sleep(3600)\n",
    "    print('yay!')\n",
    "async def main():\n",
    "    try:\n",
    "        await asyncio.wait_for(eternity(),timeout=1.0)\n",
    "    except asyncio.TimeoutError:\n",
    "        print('timeout!')\n",
    "loop=asyncio.new_event_loop()\n",
    "asyncio.set_event_loop(loop)\n",
    "loop.run_until_complete(main())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "asyncio.as_complete()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tasks=[asyncio.ensure_future(coroutine1),\n",
    "      asyncio.ensure_future(coroutine2),\n",
    "      asyncio.ensure_future(coroutine3)]\n",
    "for task in asyncio.as_completed(tasks):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Thread Scheduling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "import threading"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "thre"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TIME: 0.0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Future at 0x1eeff6df518 state=pending>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Waiting 6\n",
      "Waiting 4\n",
      "Done after 4s\n",
      "Done after 6s\n"
     ]
    }
   ],
   "source": [
    "def start_loop(loop):\n",
    "    asyncio.set_event_loop(loop)\n",
    "    loop.run_forever()\n",
    "async def do_some_work(x):\n",
    "    print('Waiting {}'.format(x))\n",
    "    await asyncio.sleep(x)\n",
    "    print('Done after {}s'.format(x))\n",
    "def more_work(x):\n",
    "    print('More work {}'.format(x))\n",
    "    time.sleep(x)\n",
    "    print('Finished more work {}'.format(x))\n",
    "start=time.time()\n",
    "new_loop=asyncio.new_event_loop()\n",
    "t=threading.Thread(target=start_loop,args=(new_loop,))\n",
    "t.start()\n",
    "print('TIME: {}'.format(time.time()-start))\n",
    "asyncio.run_coroutine_threadsafe(do_some_work(6),new_loop)\n",
    "asyncio.run_coroutine_threadsafe(do_some_work(4),new_loop)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "run_in_executor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "async def main():\n",
    "    print(f'{time.ctime()} Hello')\n",
    "    await asyncio.sleep(1.0)\n",
    "    print(f'{time.ctime()} Goodbye')\n",
    "    loop.stop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def blocking():\n",
    "    time.sleep(0.5)\n",
    "    print(f'{time.ctime()} Hello from a thread!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Thread(Thread-6, started 17196)>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sun Feb 24 10:53:34 2019 Hello\n",
      "Sun Feb 24 10:53:34 2019 Hello from a thread!\n",
      "Sun Feb 24 10:53:35 2019 Goodbye\n"
     ]
    }
   ],
   "source": [
    "loop=asyncio.new_event_loop()\n",
    "asyncio.set_event_loop(loop)\n",
    "loop.create_task(main())\n",
    "loop.run_in_executor(None,blocking)\n",
    "loop.run_forever()\n",
    "pending=asyncio.Task.all_tasks(loop=loop)\n",
    "group=asyncio.gather(*pending)\n",
    "loop.run_until_complete(group)\n",
    "loop.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*loop.run_in_executor()* use *executor* solve blocking"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Binding callback"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def callback(future):\n",
    "    print('Callback: ', future.result())\n",
    "now=lambda: time.time()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Waiting 2\n",
      "Done after 2s\n",
      "Callback:  None\n",
      "TIME:  2.000216484069824\n"
     ]
    }
   ],
   "source": [
    "start=now()\n",
    "coroutine=do_some_work(2)\n",
    "loop=asyncio.new_event_loop()\n",
    "asyncio.set_event_loop(loop)\n",
    "get_future=asyncio.ensure_future(coroutine)\n",
    "get_future.add_done_callback(callback)\n",
    "loop.run_until_complete(get_future)\n",
    "print('TIME: ', now()-start)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When task completed, execute callback."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "import functools\n",
    "def callback(t,future):\n",
    "    print('Callback:',t,future.result())\n",
    "get_future.add_done_callback(functools.partial(callback,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "loop.run_until_complete(get_future)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "if callback with one more parameters, use **functools.partial**."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}