多线程.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 多线程 vs 多进程\n",
    "- 程序：一堆代码以文本形式存入一个文档\n",
    "- 进程：程序运行的一个状态\n",
    "  - 包含地址空间，内存，数据栈等\n",
    "  - 每个进程由自己完全独立的运行环境，多进程共享数据是一个问题\n",
    "- 线程\n",
    "  - 一个进程的独立运行片段， 一个进程由多个线程组成\n",
    "  - 轻量化的进程\n",
    "  - 一个进程的多个线程间共享数据和上下文运行环境\n",
    "  - 共享互斥问题\n",
    "- 全局解释器锁（GIL）\n",
    "  - python代码的执行是由python虚拟机进行控制\n",
    "  - 在主循环中只能有一个控制线程在执行\n",
    "- python包\n",
    "  - thread： 有问题，不好用，python3改成了_thread\n",
    "  - threading： 通行的包"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 利用time函数生成两个函数\n",
    "# 程序调用\n",
    "# 计算总的执行时间\n",
    "\n",
    "import time\n",
    "\n",
    "def loop1():\n",
    "    #ctime 得到当前时间\n",
    "    print(\"start loop 1 at : \",time.ctime())\n",
    "    time.sleep(4)\n",
    "    print(\"end loop 1 at : \", time.ctime())\n",
    "    \n",
    "    \n",
    "def loop2():\n",
    "    print(\"start loop 2 at: \",time.ctime())\n",
    "    time.sleep(2)\n",
    "    print(\"end loop 2 at: \", time.ctime())\n",
    "    \n",
    "    \n",
    "def main():\n",
    "    print(\"starting at : \",time.ctime())\n",
    "    loop1()\n",
    "    loop2()\n",
    "    print(\"all done at: \", time.ctime())\n",
    "    \n",
    "if __name__ == '__main__':\n",
    "    main()    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 利用time函数生成两个函数\n",
    "# 程序调用\n",
    "# 计算总的执行时间\n",
    "\n",
    "import time\n",
    "import _thread as thread\n",
    "\n",
    "def loop1():\n",
    "    #ctime 得到当前时间\n",
    "    print(\"start loop 1 at : \",time.ctime())\n",
    "    time.sleep(4)\n",
    "    print(\"end loop 1 at : \", time.ctime())\n",
    "    \n",
    "    \n",
    "def loop2():\n",
    "    print(\"start loop 2 at: \",time.ctime())\n",
    "    time.sleep(2)\n",
    "    print(\"end loop 2 at: \", time.ctime())\n",
    "    \n",
    "    \n",
    "def main():\n",
    "    print(\"starting at : \",time.ctime())\n",
    "    #参数两个：一个是需要运行的函数名，第二个是被运行函数的参数作为元组使用，被运行的函数参数为空则使用空元祖\n",
    "    #注意： 如果被运行的函数只有一个参数，需要参数后面加上逗号。\n",
    "    thread.start_new_thread(loop1,())\n",
    "    thread.start_new_thread(loop2,())\n",
    "    print(\"all done at: \", time.ctime())\n",
    "    \n",
    "if __name__ == '__main__':\n",
    "    main()\n",
    "    #while True:\n",
    "    #    time.sleep(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "starting at :  Thu Mar 14 16:14:14 2019\n",
      "all done at:  Thu Mar 14 16:14:14 2019\n",
      "start loop 1 at : start loop 2 at :  Thu Mar 14 16:14:14 2019\n",
      "我是参数  int1\n",
      " Thu Mar 14 16:14:14 2019\n",
      "我是参数  int1 和参数 int2\n",
      "end loop 2 at :  Thu Mar 14 16:14:16 2019\n",
      "end loop 1 at :  Thu Mar 14 16:14:18 2019\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "import _thread as thread\n",
    "\n",
    "def loop1(int1):\n",
    "    #ctime 得到当前时间\n",
    "    print(\"start loop 1 at : \",time.ctime())\n",
    "    print(\"我是参数 \",int1)\n",
    "    time.sleep(4)\n",
    "    print(\"end loop 1 at : \", time.ctime())\n",
    "    \n",
    "def loop2(int1, int2):\n",
    "    #ctime 得到当前时间\n",
    "    print(\"start loop 2 at : \",time.ctime())\n",
    "    print(\"我是参数 \",int1, \"和参数\", int2)\n",
    "    time.sleep(2)\n",
    "    print(\"end loop 2 at : \", time.ctime())\n",
    "    \n",
    "def main():\n",
    "    print(\"starting at : \",time.ctime())\n",
    "    #参数两个：一个是需要运行的函数名，第二个是被运行函数的参数作为元组使用，被运行的函数参数为空则使用空元祖\n",
    "    #注意： 如果被运行的函数只有一个参数，需要参数后面加上逗号。\n",
    "    thread.start_new_thread(loop1,(\"int1\",))\n",
    "    thread.start_new_thread(loop2,(\"int1\",\"int2\"))\n",
    "    print(\"all done at: \", time.ctime())\n",
    "    \n",
    "if __name__ == '__main__':\n",
    "    main()\n",
    "    #while True:\n",
    "    #    time.sleep(1)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# threading的使用\n",
    "- 直接利用threading.Thread生成Thread实例\n",
    "  - t = threading.Thread（target=xxx，args=（xxx,））\n",
    "  - t.start():启动线程\n",
    "  - t.join():等待多线程执行完成\n",
    "- 守护线程-daemon\n",
    "  - 如果在程序中将子线程设置为守护线程，则子线程会在主线程结束后的时候自动退出\n",
    "  - 一般认为，守护线程不重要或者不允许离开主线程独立运行\n",
    "  - 守护线程案例能否有效果跟环境有关\n",
    "  \n",
    "- 线程常用属性\n",
    "  - threading.currentThread: 返回当前线程变量\n",
    "  - threading.enumerate：返回一个包含正在运行的线程的list，正在运行的线程是指线程启动后还没有运行结束\n",
    "  - threading.activeCount:返回正在运行的线程数量，效果跟len（threading.enumerate）相同\n",
    "  - thr.setName：给线程设置名字\n",
    "  - thr.getName：得到线程的名字"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "starting at :  Thu Mar 14 16:25:13 2019\n",
      "start loop 1 at :  Thu Mar 14 16:25:13 2019\n",
      "我是参数  int1\n",
      "start loop 2 at : all done at:  Thu Mar 14 16:25:13 2019\n",
      "我是参数  int1 和参数 int2\n",
      " Thu Mar 14 16:25:13 2019\n",
      "end loop 2 at :  Thu Mar 14 16:25:15 2019\n",
      "end loop 1 at :  Thu Mar 14 16:25:17 2019\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "import threading\n",
    "\n",
    "def loop1(int1):\n",
    "    #ctime 得到当前时间\n",
    "    print(\"start loop 1 at : \",time.ctime())\n",
    "    print(\"我是参数 \",int1)\n",
    "    time.sleep(4)\n",
    "    print(\"end loop 1 at : \", time.ctime())\n",
    "    \n",
    "def loop2(int1, int2):\n",
    "    #ctime 得到当前时间\n",
    "    print(\"start loop 2 at : \",time.ctime())\n",
    "    print(\"我是参数 \",int1, \"和参数\", int2)\n",
    "    time.sleep(2)\n",
    "    print(\"end loop 2 at : \", time.ctime())\n",
    "    \n",
    "def main():\n",
    "    print(\"starting at : \",time.ctime())\n",
    "    #参数两个：一个是需要运行的函数名，第二个是被运行函数的参数作为元组使用，被运行的函数参数为空则使用空元祖\n",
    "    #注意： 如果被运行的函数只有一个参数，需要参数后面加上逗号。\n",
    "    loop1T = threading.Thread(target=loop1,args=(\"int1\",))\n",
    "    loop1T.start()\n",
    "    loop2T = threading.Thread(target=loop2,args=(\"int1\",\"int2\"))\n",
    "    loop2T.start()\n",
    "    print(\"all done at: \", time.ctime())\n",
    "    \n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "starting at :  Thu Mar 14 16:28:06 2019\n",
      "start loop 1 at :  Thu Mar 14 16:28:06 2019\n",
      "我是参数  int1\n",
      "start loop 2 at :  Thu Mar 14 16:28:06 2019\n",
      "我是参数  int1 和参数 int2\n",
      "end loop 2 at :  Thu Mar 14 16:28:08 2019\n",
      "end loop 1 at :  Thu Mar 14 16:28:10 2019\n",
      "all done at:  Thu Mar 14 16:28:10 2019\n"
     ]
    }
   ],
   "source": [
    "#加入join（）等待线程结束\n",
    "import time\n",
    "import threading\n",
    "\n",
    "def loop1(int1):\n",
    "    #ctime 得到当前时间\n",
    "    print(\"start loop 1 at : \",time.ctime())\n",
    "    print(\"我是参数 \",int1)\n",
    "    time.sleep(4)\n",
    "    print(\"end loop 1 at : \", time.ctime())\n",
    "    \n",
    "def loop2(int1, int2):\n",
    "    #ctime 得到当前时间\n",
    "    print(\"start loop 2 at : \",time.ctime())\n",
    "    print(\"我是参数 \",int1, \"和参数\", int2)\n",
    "    time.sleep(2)\n",
    "    print(\"end loop 2 at : \", time.ctime())\n",
    "    \n",
    "def main():\n",
    "    print(\"starting at : \",time.ctime())\n",
    "    #参数两个：一个是需要运行的函数名，第二个是被运行函数的参数作为元组使用，被运行的函数参数为空则使用空元祖\n",
    "    #注意： 如果被运行的函数只有一个参数，需要参数后面加上逗号。\n",
    "    loop1T = threading.Thread(target=loop1,args=(\"int1\",))\n",
    "    loop1T.start()\n",
    "    loop2T = threading.Thread(target=loop2,args=(\"int1\",\"int2\"))\n",
    "    loop2T.start()\n",
    "    \n",
    "    loop1T.join()\n",
    "    loop2T.join()\n",
    "    \n",
    "    print(\"all done at: \", time.ctime())\n",
    "    \n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "main thread\n",
      "start fun\n",
      "main thread end\n",
      "end fun\n"
     ]
    }
   ],
   "source": [
    "# 非守护线程\n",
    "\n",
    "import time\n",
    "import threading\n",
    "\n",
    "\n",
    "def fun():\n",
    "    print(\"start fun\")\n",
    "    time.sleep(2)\n",
    "    print(\"end fun\")\n",
    "    \n",
    "print(\"main thread\")\n",
    "\n",
    "t1 = threading.Thread(target=fun,args=())\n",
    "t1.start()\n",
    "time.sleep(1)\n",
    "print(\"main thread end\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "main thread\n",
      "start fun\n",
      "main thread end\n",
      "end fun\n"
     ]
    }
   ],
   "source": [
    "#守护线程\n",
    "\n",
    "import time\n",
    "import threading\n",
    "\n",
    "\n",
    "def fun():\n",
    "    print(\"start fun\")\n",
    "    time.sleep(2)\n",
    "    print(\"end fun\")\n",
    "    \n",
    "print(\"main thread\")\n",
    "\n",
    "t1 = threading.Thread(target=fun,args=())\n",
    "t1.setDaemon(True)\n",
    "#t1.daemon = True\n",
    "t1.start()\n",
    "\n",
    "time.sleep(1)\n",
    "print(\"main thread end\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "starting at :  Thu Mar 14 17:05:39 2019\n",
      "start loop 1 at :  Thu Mar 14 17:05:39 2019\n",
      "start loop 2 at :  Thu Mar 14 17:05:39 2019\n",
      "start loop 3 at :  Thu Mar 14 17:05:39 2019\n",
      "end loop 3 at :  Thu Mar 14 17:05:41 2019\n",
      "正在运行的线程名字是： MainThread\n",
      "正在运行的线程名字是： Thread-4\n",
      "正在运行的线程名字是： Thread-5\n",
      "正在运行的线程名字是： IPythonHistorySavingThread\n",
      "正在运行的线程名字是： Thread-3\n",
      "正在运行的线程名字是： THR_1\n",
      "正在运行的线程名字是： THR_2\n",
      "正在运行的子线程数量为： 7\n",
      "all done at:  Thu Mar 14 17:05:42 2019\n",
      "end loop 2 at :  Thu Mar 14 17:05:43 2019\n",
      "end loop 1 at :  Thu Mar 14 17:05:44 2019\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "import threading\n",
    "\n",
    "def loop1():\n",
    "    #ctime 得到当前时间\n",
    "    print(\"start loop 1 at : \",time.ctime())\n",
    "    time.sleep(5)\n",
    "    print(\"end loop 1 at : \", time.ctime())\n",
    "    \n",
    "def loop2():\n",
    "    #ctime 得到当前时间\n",
    "    print(\"start loop 2 at : \",time.ctime())\n",
    "    time.sleep(4)\n",
    "    print(\"end loop 2 at : \", time.ctime())\n",
    "\n",
    "def loop3():\n",
    "    #ctime 得到当前时间\n",
    "    print(\"start loop 3 at : \",time.ctime())\n",
    "    time.sleep(2)\n",
    "    print(\"end loop 3 at : \", time.ctime())\n",
    "    \n",
    "def main():\n",
    "    print(\"starting at : \",time.ctime())\n",
    "    #参数两个：一个是需要运行的函数名，第二个是被运行函数的参数作为元组使用，被运行的函数参数为空则使用空元祖\n",
    "    #注意： 如果被运行的函数只有一个参数，需要参数后面加上逗号。\n",
    "    t1 = threading.Thread(target=loop1,args=())\n",
    "    t1.setName(\"THR_1\")\n",
    "    t1.start()\n",
    "    t2 = threading.Thread(target=loop2,args=())\n",
    "    t2.setName(\"THR_2\")\n",
    "    t2.start()\n",
    "    t3 = threading.Thread(target=loop3,args=())\n",
    "    t3.setName(\"THR_3\")\n",
    "    t3.start()\n",
    "    time.sleep(3)\n",
    "    \n",
    "    for thr in threading.enumerate():\n",
    "        print(\"正在运行的线程名字是： {0}\".format(thr.getName()))\n",
    "    print(\"正在运行的子线程数量为： {0}\".format(threading.activeCount()))\n",
    "    print(\"all done at: \", time.ctime())\n",
    "    \n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 直接继承自threading.Thread\n",
    "- 直接继承Thread\n",
    "- 重写run函数\n",
    "- 类实例可以直接运行"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the args for this class is 0\n",
      "the args for this class is 1\n",
      "the args for this class is 2\n",
      "the args for this class is 3\n",
      "the args for this class is 4\n",
      "main thread is done!!!!!!!!\n"
     ]
    }
   ],
   "source": [
    "import threading\n",
    "import time\n",
    "\n",
    "class MyThread(threading.Thread):\n",
    "    def __init__(self,arg):\n",
    "        super(MyThread,self).__init__()\n",
    "        self.arg = arg\n",
    "        \n",
    "    def run(self):\n",
    "        time.sleep(2)\n",
    "        print(\"the args for this class is {0}\".format(self.arg))\n",
    "        \n",
    "for i in range(5):\n",
    "    t = MyThread(i)\n",
    "    t.start()\n",
    "    t.join()\n",
    "    \n",
    "print(\"main thread is done!!!!!!!!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}