图解Python 【第八篇】：网络编程-进程、线程和协程

时间：2022-08-28 23:46:32

本节内容一览图：

图解Python 【第八篇】：网络编程-进程、线程和协程

本章内容：

  • 同步和异步
  • 线程（线程锁、threading.Event、queue 队列、生产者消费者模型、自定义线程池）
  • 进程（数据共享、进程池）
  • 协程

一、同步和异步

图解Python 【第八篇】：网络编程-进程、线程和协程

你叫我去吃饭，我听到了就立刻和你去吃饭，如果我没听到，你就一直叫我，直到我听见和你一起去吃饭，这个过程叫同步；异步过程指你叫我去吃饭，然后你就去吃饭了，而不管我是否和你一起去吃饭。而我得到消息后可能立即就走，也可能过段时间再走。吃货学python不过就是吃顿饭的事儿，。。。

　　官方的解释搬过来：

　　　　同步是指：发送方发出数据后，等接收方发回响应以后才发下一个数据包的通讯方式。

　　　　异步是指：发送方发出数据后，不等接收方发回响应，接着发送下个数据包的通讯方式。

二、进程、线程与协成的概念

2.1、什么是进程？

　 进程，是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。前面的话我也没懂，用非官方的白话来解释就是——执行中的程序是进程，比如qq不是进程，但是当我们双击qq开始使用它的时候，它就变成了一个进程。我们写的python程序，只有当我们执行它的时候，它才是进程。我们正在执行的IE浏览器，QQ，pycharm都是进程，从操作系统的角度来讲，每一个进程都有它自己的内存空间，进程之间的内存是独立的。

2.2、什么是线程？

　　线程，有时被称为轻量级进程，是程序执行流的最小单元。线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务；我们可以理解为，线程是属于进程的，我们平时写的简单程序，是单线程的，多线程和单线程的区别在于多线程可以同时处理多个任务，这时候我们可以理解为多线程和多进程是一样的，我可以在我的进程中开启一个线程放音乐，也可以开启另外的线程聊qq，但是进程之间的内存独立，而属于同一个进程多个线程之间的内存是共享的，多个线程可以直接对它们所在进程的内存数据进行读写并在线程间进行交换。

2.3、进程与线程之间的关系

先推荐一个链接，这篇文章用漫画的形式讲解了进程与线程的关系：http://www.ruanyifeng.com/blog/2013/04/processes_and_threads.html

图解Python 【第八篇】：网络编程-进程、线程和协程

关于python线程的那个传说：

　　在python界一直有着一个古老的传说，那就是python的多线程是鸡肋，那么这个传说的信度到底有多少呢？如果我们的代码是CPU密集型（涉及到大量的计算），多个线程的代码很有可能是线性执行的，所以这种情况下多线程是鸡肋，效率可能还不如单线程，因为有context switch（其实就是线程之间的切换和线程的创建等等都是需要消耗时间的）；但是：如果是IO密集型，多线程可以明显提高效率。例如制作爬虫，绝大多数时间爬虫是在等待socket返回数据。这个时候C代码里是有release GIL的，最终结果是某个线程等待IO的时候其他线程可以继续执行。

　　那么，为什么我们大python会这么不智能呢？我们都知道，python是一种解释性语言，在python执行的过程中，需要解释器一边解释一边执行，我们之前也介绍了，同一个进程的线程之间内存共享，那么就会出现内存资源的安全问题，python为了线程安全，就设置了全局解释器锁机制，既一个进程中同时只能有一个线程访问cpu。作为解释型语言，python能引入多线程的概念就已经非常不易了，目前看到的资料php和perl等多线程机制都是不健全的。解释型语言做多线程的艰难程度可以想见。。。具体下面的链接推荐：python的最难问题。

　　正是由于python多线程的缺陷，我们在这里需要引入协成的概念

2.4、什么是协程？

　　协程是一种用户态的轻量级线程。如果说多进程对于多CPU，多线程对应多核CPU，那么事件驱动和协程则是在充分挖掘不断提高性能的单核CPU的潜力。我们既可以利用异步优势，又可以避免反复系统调用，还有进程切换造成的开销，这就是协程。协程也是单线程，但是它能让原来要使用异步+回调方式写的非人类代码,可以用看似同步的方式写出来。它是实现推拉互动的所谓非抢占式协作的关键。对于python来说，由于python多线程中全局解释器导致的同时只能有一个线程访问cpu，所以对协程需求就相比于其他语言更为紧迫。

什么算协程：

  1. 必须在只有一个单线程里实现并发
  2. 修改共享数据不需加锁
  3. 用户程序里自己保存多个控制流的上下文栈
  4. 一个协程遇到IO操作自动切换到其它协程

协程的利弊：

协程的好处：

  • 无需线程上下文切换的开销
  • 无需原子操作锁定及同步的开销
    • 　　"原子操作(atomic operation)是不需要synchronized"，所谓原子操作是指不会被线程调度机制打断的操作；这种操作一旦开始，就一直运行到结束，中间不会有任何 context switch （切换到另一个线程）。原子操作可以是一个步骤，也可以是多个操作步骤，但是其顺序是不可以被打乱，或者切割掉只执行部分。视作整体是原子性的核心。
  • 方便切换控制流，简化编程模型
  • 高并发+高扩展性+低成本：一个CPU支持上万的协程都不是问题。所以很适合用于高并发处理。

缺点：

  • 无法利用多核资源：协程的本质是个单线程,它不能同时将 单个CPU 的多个核用上,协程需要和进程配合才能运行在多CPU上.当然我们日常所编写的绝大部分应用都没有这个必要，除非是cpu密集型应用。
  • 进行阻塞（Blocking）操作（如IO时）会阻塞掉整个程序

2.5、总结：

图解Python 【第八篇】：网络编程-进程、线程和协程

进程、线程与协程

　　从硬件发展来看，从最初的单核单CPU，到单核多CPU，多核多CPU，似乎已经到了极限了，但是单核CPU性能却还在不断提升。server端也在不断的发展变化。如果将程序分为IO密集型应用和CPU密集型应用，二者的server的发展如下：

　　　IO密集型应用: 多进程->多线程->事件驱动->协程
　　　CPU计算密集型应用:多进程-->多线程

　调度和切换的时间：进程   >   线程   >  协程

利于弊：

  • 进程只能在一个时间干一件事，如果想同时干两件事或多件事，进程就无能为力了。所以需要线程
  • 进程在执行的过程中如果阻塞，例如等待输入，整个进程就会挂起，即使进程中有些工作不依赖于输入的数据，也将无法执行
  • python为了线程安全，就设置了全局解释器锁机制，python多线程的缺陷，我们在这里需要引入协成的概念

进程、线程和协成的详解如下：

　　　　进程篇：http://www.cnblogs.com/Eva-J/articles/5110844.html

　　　　线程篇——基础篇：http://www.cnblogs.com/Eva-J/articles/5109737.html

　　　　线程篇——进阶篇：http://www.cnblogs.com/Eva-J/articles/5110160.html

　　　　线程篇——线程池：http://www.cnblogs.com/Eva-J/articles/5106564.html

　　　　协程篇：http://www.cnblogs.com/Eva-J/articles/5110969.html

三、线程

Python的标准库提供了两个模块：_thread和threading，_thread是低级模块，threading是高级模块，对_thread进行了封装。绝大多数情况下，我们只需要使用threading这个高级模块

3.1、threading模块

线程有2种调用方式，如下：

直接调用

import threading

import time

def sayhi(num): #定义每个线程要运行的函数

    print("running on number:%s" %num)

    time.sleep(3)

if __name__ == '__main__':

    t1 = threading.Thread(target=sayhi,args=(1,)) #生成一个线程实例

    t2 = threading.Thread(target=sayhi,args=(2,)) #生成另一个线程实例

    t1.start() #启动线程

    t2.start() #启动另一个线程

    print(t1.getName()) #获取线程名

    print(t2.getName())

继承式调用

import threading

import time

class MyThread(threading.Thread):

    def __init__(self,num):

        threading.Thread.__init__(self)

        self.num = num

    def run(self):#定义每个线程要运行的函数

        print("running on number:%s" %self.num)

        time.sleep(3)

if __name__ == '__main__':

    t1 = MyThread(1)

    t2 = MyThread(2)

    t1.start()

    t2.start()

Thread方法说明

t.start() : 激活线程，

t.getName() : 获取线程的名称

t.setName() ： 设置线程的名称

t.name : 获取或设置线程的名称

t.is_alive() ： 判断线程是否为激活状态

t.isAlive() ：判断线程是否为激活状态

t.setDaemon() 设置为后台线程或前台线程（默认：False）;通过一个布尔值设置线程是否为守护线程，必须在执行start()方法之后才可以使用。如果是后台线程，主线程执行过程中，后台线程也在进行，主线程执行完毕后，后台线程不论成功与否，均停止；如果是前台线程，主线程执行过程中，前台线程也在进行，主线程执行完毕后，等待前台线程也执行完成后，程序停止

t.isDaemon() ： 判断是否为守护线程

t.ident ：获取线程的标识符。线程标识符是一个非零整数，只有在调用了start()方法之后该属性才有效，否则它只返回None。

t.join() ：逐个执行每个线程，执行完毕后继续往下执行，该方法使得多线程变得无意义

t.run() ：线程被cpu调度后自动执行线程对象的run方法

 3.2、线程锁threading.Lock和threading.RLock递归锁

线程锁(互斥锁Mutex)

小结：

threading.RLock和threading.Lock 的区别

RLock允许在同一线程中被多次acquire。而Lock却不允许这种情况。 如果使用RLock，那么acquire和release必须成对出现，即调用了n次acquire，必须调用n次的release才能真正释放所占用的琐。

3.3、Semaphore(信号量)

互斥锁 同时只允许一个线程更改数据，而Semaphore是同时允许一定数量的线程更改数据 ，比如厕所有3个坑，那最多只允许3个人上厕所，后面的人只能等里面有人出来了才能再进去。

import threading,time

def run(n):

    semaphore.acquire()

    time.sleep(1)

    print("run the thread: %s\n" %n)

    semaphore.release()

if __name__ == '__main__':

    num= 0

    semaphore  = threading.BoundedSemaphore(5) #最多允许5个线程同时运行

    for i in range(20):

        t = threading.Thread(target=run,args=(i,))

        t.start()

while threading.active_count() != 1:

    pass #print threading.active_count()

else:

    print('----all threads done---')

    print(num)

3.4、Events

通过Event来实现两个或多个线程间的交互，下面是一个红绿灯的例子，即起动一个线程做交通指挥灯，生成几个线程做车辆，车辆行驶按红灯停，绿灯行的规则

import threading,time

import random

def light():

    if not event.isSet():

        event.set() #wait就不阻塞 #绿灯状态

    count = 0

    while True:

        if count < 10:

            print('\033[42;1m--green light on---\033[0m')

        elif count <13:

            print('\033[43;1m--yellow light on---\033[0m')

        elif count <20:

            if event.isSet():

                event.clear()

            print('\033[41;1m--red light on---\033[0m')

        else:

            count = 0

            event.set() #打开绿灯

        time.sleep(1)

        count +=1

def car(n):

    while 1:

        time.sleep(random.randrange(10))

        if  event.isSet(): #绿灯

            print("car [%s] is running.." % n)

        else:

            print("car [%s] is waiting for the red light.." %n)

if __name__ == '__main__':

    event = threading.Event()

    Light = threading.Thread(target=light)

    Light.start()

    for i in range(3):

        t = threading.Thread(target=car,args=(i,))

        t.start()

未完，不想写了，为什么不想写了，因为

图解Python 【第八篇】：网络编程-进程、线程和协程

图解Python 【第八篇】：网络编程-进程、线程和协程

声明：

本人在学习老男孩python自动化网络课程后，结合所学整理做次笔记，本文内容多出

Alex老师博客:http://www.cnblogs.com/alex3714/articles/5230609.html

武沛齐老师博客:http://www.cnblogs.com/wupeiqi/articles/5040827.html

感谢老男孩教育老师Alex，武沛齐老师，本文多从二位老师文章中结合整理

http://www.cnblogs.com/Eva-J/p/5106688.html

相关文章