👏作者简介：大家好，我是爱敲代码的小王，CSDN博客博主,Python小白
📕系列专栏：python入门到实战、Python爬虫开发、Python办公自动化、Python数据分析、Python前后端开发
📧如果文章知识点有错误的地方，请指正！和大家一起学习，一起进步👀
🔥如果感觉博主的文章还不错的话，请👍三连支持👍一下博主哦
🍂博主正在努力完成2023计划中：以梦为马，扬帆起航，2023追梦人

🔥🔥🔥 python入门到实战专栏：从入门到实战 

🔥🔥🔥 Python爬虫开发专栏：从入门到实战

🔥🔥🔥 Python办公自动化专栏：从入门到实战

🔥🔥🔥 Python数据分析专栏：从入门到实战

🔥🔥🔥 Python前后端开发专栏：从入门到实战

目录

并发编程介绍

串行、并行与并发的区别

 进程、线程、协程的区别

线程是什么？ 

协程是什么？

 同步和异步介绍

线程Thread 

join()

守护线程

---

并发编程介绍

串行、并行与并发的区别

1 串行(serial)：一个CPU上，按顺序完成多个任务

2 并行(parallelism)：指的是任务数小于等于cpu核数，即任务真的是一起执行的

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

 进程、线程、协程的区别

一个故事说明进程、线程、协程的关系

乔布斯想开工厂生产手机，费劲力气，制作一条生产线，这个 生产线上有很多的器件以及材料。一条生产线就是一个进程。 只有生产线是不够的，所以找五个工人来进行生产，这个工人 能够利用这些材料最终一步步的将手机做出来，这五个工人就是五个线程。 

为了提高生产率，想到3种办法：

1 一条生产线上多招些工人，一起来做手机，这样效率是成倍増长，即单进程多线程方式

2 多条生产线，每个生产线上多个工人，即多进程多线程

3 乔布斯深入一线发现工人不是那么忙，有很多等待时间。于是规定：如果某个员工在等待生 产线某个零件生产时 ，不要闲着，干点其他工作。也就是说：如果一个线程等待某些条件， 可以充分利用这个时间去做其它事情，这就是：协程方式。 

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

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

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

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

进程(Process)：拥有自己独立的堆和栈，既不共享堆，也不共享栈，进程由操作系统调度； 进程切换需要的资源很最大，效率低

线程(Thread)：拥有自己独立的栈和共享的堆，共享堆，不共享栈，标准线程由操作系统调 度；线程切换需要的资源一般，效率一般（当然了在不考虑GIL的情况下）

协程(coroutine)：拥有自己独立的栈和共享的堆，共享堆，不共享栈，协程由程序员在协程 的代码里显示调度；协程切换任务资源很小，效率高 

 进程是什么？

进程（Process）是一个具有一定独立功能的程序关于某个数据集合的一次运行活动

现代操作系统比如Mac OS X，Linux，Windows等，都是支持 “多任务”的操作系统，叫“多任务”呢？简单地说，就是操作系统 可以同时运行多个任务。打个比方，你一边在用逛淘宝，一边 在听音乐，一边在用微信聊天，这就是多任务，至少同时有3个任务正在运行。还有很多任务悄悄地在后台同时运行着，只是 桌面上没有显示而已。 

对于操作系统来说，一个任务就是一个进程（Process），比如打开 一个浏览器就是启动一个浏览器进程，就启动了一个记事本进程， 打开两个记事本就启动了两个记事本进程，打开一个Word就启动了 一个Word进程。

线程是什么？ 

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

有些进程还不止同时干一件事，比如微信，它可以同时进行打字聊天，视频聊天，朋友圈等事情。在一个进程内部，要同时干多件事，就需要同时运行多个“子任务”，我们把进程内的这些 “子任务”称为线程（Thread）。

并发编程解决方案： 

多任务的实现有3种方式：

1 多进程模式

2 多线程模式

3 多进程+多线程模式

启动多个进程，每个进程虽然只有一个线程，但多个进程可以一块执行多个任务

启动一个进程，在一个进程内启动多个线程，这样，多个线程也可以一块执行多个任务

启动多个进程，每个进程再启动多个线程，这样同时执行的任务就更多了，当然这种模型更 复杂，实际很少采用。 

协程是什么？

协程，Coroutines，也叫作纤程(Fiber)，是一种在线程中，比线程 更加轻量级的存在，由程序员自己写程序来管理。 当出现IO阻塞时，CPU一直等待IO返回，处于空转状态。这时候用协程，可以执行其他任务。当IO返回结果后，再回来处理数据。充分利用了IO等待的时间，提高了效率。

 同步和异步介绍

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

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

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

 

同步方式通信：

1 小童买一本书《Python实战笔记》。

2 书店老板说：等三分钟啊，我帮你查查。

3 小童等一小时

4 老板说，找到书了，发给你

异步方式通信：

1 小童买一本电子书《Python实战笔记》。

2 书店老板说：我查一下，有结果了告诉你。

3 小童刷抖音一小时

4 老板说，找到书了，发给你 

线程Thread 

什么是线程

线程(Thread)特点：

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

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

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

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

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

线程的创建方式 

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

线程的创建可以通过分为两种方式：

1. 方法包装

2. 类包装

线程的执行统一通过 start() 方法

线程的创建方式(方法包装)

#encoding=utf-8
#方法方式创建线程
from threading import Thread
from time import sleep
def func1(name):
    for i in range(3):
        print(f"thread:{name} :{i}")
        sleep(1)
if __name__ == '__main__':
    print("主线程，start")
    #创建线程
    t1 = Thread(target=func1,args=("t1",))
    t2 = Thread(target=func1,args=("t2",))
    #启动线程
    t1.start()
    t2.start()
    print("主线程，end")
'''
运行结果可能会出现换行问题，是因为多个线程抢夺控制台
输出的IO流。
比如，如下的输出换行就没有按照预想的显示：
主线程，start
thread:t1 :0
thread:t2 :0
主线程，end
thread:t2 :1thread:t1 :1
thread:t2 :2
thread:t1 :2
'''

线程的创建方式(类包装)

#encoding=utf-8
#类的方式创建线程
from threading import Thread
from time import sleep
class MyThread(Thread):
    def __init__(self,name):
        Thread.__init__(self)
        self.name =name
    def run(self):
        for i in range(3):
            print(f"thread:{self.name} : {i}")
            sleep(1)
if __name__ == '__main__':
    print("主线程，start")
    #创建线程(类的方式)
    t1 = MyThread('t1')
    t2 = MyThread('t2')
    #启动线程
    t1.start()
    t2.start()
    print("主线程，end")

join()

之前的代码，主线程不会等待子线程结束。 如果需要等待子线程结束后，再结束主线程，可使用join()方法。

#encoding=utf-8
from threading import Thread
from time import sleep
def func1(name):
    for i in range(3):
        print(f"thread:{name} :{i}")
        sleep(1)
if __name__ == '__main__':
    print("主线程，start")
    #创建线程
    t1 = Thread(target=func1,args=("t1",))
    t2 = Thread(target=func1,args=("t2",))
    #启动线程
    t1.start()
    t2.start()
    #主线程会等待t1,t2结束后，再往下执行
    t1.join()
    t2.join()
    print("主线程，end")

守护线程

在行为上还有一种叫守护线程，主要的特征是它的生命周期。主线 程死亡，它也就随之死亡。在python中，线程通过 setDaemon(True|False) 来设置是否为守护线程。

守护线程的作用：

守护线程作用是为其他线程提供便利服务，守护线程最典型的应用就是 GC (垃圾收集器)。

#encoding=utf-8
from threading import Thread
from time import sleep
class MyThread(Thread):
    def __init__(self,name):
        Thread.__init__(self)
        self.name =name
    def run(self):
        for i in range(3):
            print(f"thread:{self.name} : {i}")
            sleep(1)
if __name__ == '__main__':
    print("主线程，start")
    #创建线程(类的方式)
    t1 = MyThread('t1')
    #t1设置为守护线程
    t1.setDaemon(True)#3.10后被废弃，可以直接：t1.daemon=True
    #启动线程
    t1.start()
    print("主线程，end")