Python并发编程学习记录

1、初识并发编程

1.1、串行，并行，并发

串行(serial)：一个cpu上按顺序完成多个任务；

并行(parallelism)：任务数小于或等于cup核数，多个任务是同时执行的；

并发(concurrency)：一个CPU采用时间片管理方式，交替的处理多个任务。一般是任务数多余cpu核数，通过操作系统的各种任务调度算法，实现用多个任务一起执行(实际上总有一些任务不在执行，因为切换任务的速度相当快，看上去一起执行而已）。

1.2、进程，线程，协程

通过案例了解概念：

进程：我的工厂有一条生产线，这条生产线就是一个进程。

线程：在我工厂的一条生产线上，我安排了五名工人在生产线上工作，五名工人就是五个线程。

一条生产线上有多名工人就是单进程多线程。

多个生产线上有多名工人就是多进程多线程。

协程：作为一个资本家，我看到工人在生产任务较轻的时候休息是不能接受的，于是我规定当生产线没有任务时，就去帮工厂打扫卫生，即如果一个线程等待某些条件，可以充分利用这个时间去做其它事情，这就是协程。

进程，线程和协程的总结：

①、线程是程序执行的最小单位，而进程是操作系统分配资源的最小单位；

②、一个进程由一个或多个线程组成，线程是一个进程中代码的不同执行路线；

③、进程之间相互独立，但同一进程下的各个线程之间共享程序的内存空间(包括代码段、数据集、堆等)及一些进程级的资源(如打开文件和信号)，某进程内的线程在其它进程不可见；

④、调度和切换：线程上下文切换比进程上下文切换要快得多；

⑤、进程(Process)：拥有自己独立的堆和栈，既不共享堆，也不共享栈，进程由操作系统调度；进程切换需要的资源很最大，效率低(是一个具有一定独立功能的程序关于某个数据集合的一次运行活动)；

⑥、线程(Thread)：拥有自己独立的栈和共享的堆，共享堆，不共享栈，标准线程由操作系统调度；线程切换需要的资源一般，效率一般（线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位）；

⑦、协程coroutine)：拥有自己独立的栈和共享的堆，共享堆，不共享栈，协程由程序员在协程的代码里显示调度；协程切换任务资源很小，效率高(协程是一种在线程中，比线程更加轻量级的存在，由程序员自己写程序来管理。)。

1.3、同步，异步

概述：同步和异步强调的是消息通信机制 (synchronous communication/ asynchronous communication)。 

同步：A调用B，等待B返回结果后，A继续执行。

异步：A调用B，A继续执行，不等待B返回结果；B有结果了，通知A，A再做处理。

2、线程(Thread)

特点：

①、是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位；

②、线程是程序执行的最小单位，而进程是操作系统分配资源的最小单位；

③、一个进程由一个或多个线程组成，线程是一个进程中代码的不同执行路线；

④、拥有自己独立的栈和共享的堆，共享堆，不共享栈，标准线程由操作系统调度；

⑤、调度和切换：线程上下文切换比进程上下文切换要快得多。

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

线程的创建方式：

①、方法包装

②、类包装

提示：线程的执行统一通过start()方法。

2.1、通过方法包装创建线程

概述：

①、通过方法包装创建线程时，线程通过Thread()方法进行创建，Thread()方法有两个参数，参数1为target，表示线程开启后执行哪个方法(方法不要带小括号，带小括号表示运行(或者说叫调用)某个函数，不带小括号表示存储了某个函数的地址)，参数2为args，表示执行target指定的函数时传入的参数(args的类型是元组)。

②、线程通过start()方法开启，只创建线程而不开启线程，线程是不会运行的。

实操：通过方法包装的方式创建两个线程，线程开启后都打印信息(为了让程序慢速运行，引入sleep()函数)，通过实例观察多个线程间是如何运行的。

from threading import Thread
from time import sleep

# 线程触发后运行的函数
def fun1(name):
    print(f"线程{name},start")
    for i in range(5):
        print(f"线程{name}正在打印")
        # 降低程序运行的速度
        sleep(1)
    print(f"线程{name},end")

# 程序的入口
if __name__ == '__main__':
    print("主线程,start")
    # 创建线程,target表示线程开启后执行哪个方法,args表示执行方法传入的参数(args的类型是元组)
    t1 = Thread(target=fun1,args=("t1",))
    t2 = Thread(target=fun1,args=("t2",))
    # 启动线程
    t1.start()
    t2.start()
    print("主线程,end")

运行结果如下：

案例总结：①、主线程，线程t1，线程t2这三个线程是相互独立的，即使主线程结束其他线程仍然能继续运行。

②、由于只有一个cpu来处理，所以不同的线程要抢夺同一个打印流进行打印，导致打印顺序较乱。

2.2、类包装创建线程

概述：类包装创建线程指创建一个实例对象，实例对象对应的类继承了Thread，线程运行后执行指定类中的run函数(这里是对父类run函数的重写)，指定类中的构造方法还要调用Thread的构造方法，调用指定函数进行线程创建时，参数的个数取决于指定类中__init__除self外参数的个数。

from threading import Thread
from time import sleep

# 传入的参数一定是Thread
class myThread(Thread):
    def __init__(self,name):
        # 调用Thread的构造方法
        Thread.__init__(self)
        self.name = name

    # 函数名不能修改，这是对原有实例方法进行重写
    def run(self):
        print(f"线程{self.name},start")
        for i in range(5):
            print(f"线程{self.name}正在打印")
            # 降低程序运行的速度
            sleep(1)
        print(f"线程{self.name},end")

if __name__ == '__main__':
    print("主线程,start")
    # 创建线程
    t1 = myThread("t1")
    t2 = myThread("t2")
    # 启动线程
    t1.start()
    t2.start()
    print("主线程,end")

运行结果如下：

2.3、join()和守护线程

2.3.1、join()

概述：在前面的实操中可以发现，主线程，t1线程和t2线程都作为独立线程，主线程提前结束也不会影响其他线程的运行，但是如果现在有需求让主线程等待其他线程结束后再结束主线程，此时就可以用到join()方法。

实操：创建两个线程，分别为t3和t4，指定主线程要等待t3进程结束再结束主线程。

from threading import Thread
from time import sleep

def fun2(name):
    for i in range(3):
        print(f"{name}线程start")
        sleep(1)
        print(f"{name}线程end")

if __name__ == '__main__':
    print("主线程开启")
    # 创建线程(创建线程时不要省略参数的指定，不如会报错)
    t3 = Thread(target=fun2,args=("t3",))
    t4 = Thread(target=fun2,args=("t4",))
    # 开启线程
    t3.start()
    t4.start()
    # 指定主线程在特定线程结束后结束
    t3.join()

    print("主线程结束")

运行结果如下(为了突出运行结果，这里我选了一个极端的结果，由于t3和t4运行的是同样的程序，运行速度完成看两个线程谁抢打印流抢得快，t4有时会在t3结束前结束)

2.3.2、守护线程

概述：有一种线程叫守护线程，主要的特征是它的生命周期随着主线程的死亡而死亡(由于这种特征导致守护线程一般都是为主线程服务)。在python中，线程通过setDaemon(Tr