python进程创建线程

发布时间: 2022-05-26 08:32:19

㈠ python面试题，线程与进程的区别，Python中如何创建多线程

进程和线程

这两个概念属于操作系统，我们经常听说，但是可能很少有人会细究它们的含义。对于工程师而言，两者的定义和区别还是很有必要了解清楚的。

首先说进程，进程可以看成是 CPU执行的具体的任务 。在操作系统当中，由于CPU的运行速度非常快，要比计算机当中的其他设备要快得多。比如内存、磁盘等等，所以如果CPU一次只执行一个任务，那么会导致CPU大量时间在等待这些设备，这样操作效率很低。为了提升计算机的运行效率，把机器的技能尽可能压榨出来，CPU是轮询工作的。也就是说 它一次只执行一个任务，执行一小段碎片时间之后立即切换 ，去执行其他任务。

所以在早期的单核机器的时候，看起来电脑也是并发工作的。我们可以一边听歌一边上网，也不会觉得卡顿。但实际上，这是CPU轮询的结果。在这个例子当中，听歌的软件和上网的软件对于CPU而言都是 独立的进程 。我们可以把进程简单地理解成运行的应用，比如在安卓手机里面，一个app启动的时候就会对应系统中的一个进程。当然这种说法不完全准确， 一个应用也是可以启动多个进程的 。

进程是对应CPU而言的，线程则更多针对的是程序。即使是CPU在执行当前进程的时候，程序运行的任务其实也是有分工的。举个例子，比如听歌软件当中，我们需要显示歌词的字幕，需要播放声音，需要监听用户的行为，比如是否发生了切歌、调节音量等等。所以，我们需要 进一步拆分CPU的工作 ，让它在执行当前进程的时候，继续通过轮询的方式来同时做多件事情。

进程中的任务就是线程，所以从这点上来说， 进程和线程是包含关系 。一个进程当中可以包含多个线程，对于CPU而言，不能直接执行线程，一个线程一定属于一个进程。所以我们知道，CPU进程切换切换的是执行的应用程序或者是软件，而进程内部的线程切换，切换的是软件当中具体的执行任务。

关于进程和线程有一个经典的模型可以说明它们之间的关系，假设CPU是一家工厂，工厂当中有多个车间。不同的车间对应不同的生产任务，有的车间生产汽车轮胎，有的车间生产汽车骨架。但是工厂的电力是有限的，同时只能满足一个厂房的使用。

为了让大家的进度协调，所以工厂需要轮流提供各个车间的供电。 这里的车间对应的就是进程 。

一个车间虽然只生产一种产品，但是其中的工序却不止一个。一个车间可能会有好几条流水线，具体的生产任务其实是流水线完成的，每一条流水线对应一个具体执行的任务。但是同样的， 车间同一时刻也只能执行一条流水线 ，所以我们需要车间在这些流水线之间切换供电，让各个流水线生产进度统一。

这里车间里的 流水线自然对应的就是线程的概念 ，这个模型很好地诠释了CPU、进程和线程之间的关系。实际的原理也的确如此，不过CPU中的情况要比现实中的车间复杂得多。因为对于进程和CPU来说，它们面临的局面都是实时变化的。车间当中的流水线是x个，下一刻可能就成了y个。

了解完了线程和进程的概念之后，对于理解电脑的配置也有帮助。比如我们买电脑，经常会碰到一个术语，就是这个电脑的CPU是某某核某某线程的。比如我当年买的第一台笔记本是4核8线程的，这其实是在说这台电脑的CPU有 4个计算核心 ，但是使用了超线程技术，使得可以把一个物理核心模拟成两个逻辑核心。相当于我们可以用4个核心同时执行8个线程，相当于8个核心同时执行，但其实有4个核心是模拟出来的虚拟核心。

有一个问题是 为什么是4核8线程而不是4核8进程呢 ？因为CPU并不会直接执行进程，而是执行的是进程当中的某一个线程。就好像车间并不能直接生产零件，只有流水线才能生产零件。车间负责的更多是资源的调配，所以教科书里有一句非常经典的话来诠释： 进程是资源分配的最小单元，线程是CPU调度的最小单元 。

启动线程

Python当中为我们提供了完善的threading库，通过它，我们可以非常方便地创建线程来执行多线程。

首先，我们引入threading中的Thread，这是一个线程的类，我们可以通过创建一个线程的实例来执行多线程。

from threading import Thread t = Thread(target=func, name='therad', args=(x, y)) t.start()

简单解释一下它的用法，我们传入了三个参数，分别是 target，name和args ，从名字上我们就可以猜测出它们的含义。首先是target，它传入的是一个方法，也就是我们希望多线程执行的方法。name是我们为这个新创建的线程起的名字，这个参数可以省略，如果省略的话，系统会为它起一个系统名。当我们执行Python的时候启动的线程名叫MainThread，通过线程的名字我们可以做区分。args是会传递给target这个函数的参数。

我们来举个经典的例子：

import time, threading # 新线程执行的代码: def loop(n): print('thread %s is running...' % threading.current_thread().name) for i in range(n): print('thread %s >>> %s' % (threading.current_thread().name, i)) time.sleep(5) print('thread %s ended.' % threading.current_thread().name) print('thread %s is running...' % threading.current_thread().name) t = threading.Thread(target=loop, name='LoopThread', args=(10, )) t.start() print('thread %s ended.' % threading.current_thread().name)

我们创建了一个非常简单的loop函数，用来执行一个循环来打印数字，我们每次打印一个数字之后这个线程会睡眠5秒钟，所以我们看到的结果应该是每过5秒钟屏幕上多出一行数字。

我们在Jupyter里执行一下：

表面上看这个结果没毛病，但是其实有一个问题，什么问题呢？ 输出的顺序不太对 ，为什么我们在打印了第一个数字0之后，主线程就结束了呢？另外一个问题是，既然主线程已经结束了， 为什么Python进程没有结束 ，还在向外打印结果呢？

因为线程之间是独立的，对于主线程而言，它在执行了t.start()之后，并 不会停留，而是会一直往下执行一直到结束 。如果我们不希望主线程在这个时候结束，而是阻塞等待子线程运行结束之后再继续运行，我们可以在代码当中加上t.join()这一行来实现这点。

t.start() t.join() print('thread %s ended.' % threading.current_thread().name)

join操作可以让主线程在join处挂起等待，直到子线程执行结束之后，再继续往下执行。我们加上了join之后的运行结果是这样的：

这个就是我们预期的样子了，等待子线程执行结束之后再继续。

我们再来看第二个问题，为什么主线程结束的时候，子线程还在继续运行，Python进程没有退出呢？这是因为默认情况下我们创建的都是用户级线程，对于进程而言， 会等待所有用户级线程执行结束之后才退出 。这里就有了一个问题，那假如我们创建了一个线程尝试从一个接口当中获取数据，由于接口一直没有返回，当前进程岂不是会永远等待下去？

这显然是不合理的，所以为了解决这个问题，我们可以把创建出来的线程设置成 守护线程 。

守护线程

守护线程即daemon线程，它的英文直译其实是后台驻留程序，所以我们也可以理解成 后台线程 ，这样更方便理解。daemon线程和用户线程级别不同，进程不会主动等待daemon线程的执行， 当所有用户级线程执行结束之后即会退出。进程退出时会kill掉所有守护线程 。

我们传入daemon=True参数来将创建出来的线程设置成后台线程：

t = threading.Thread(target=loop, name='LoopThread', args=(10, ), daemon=True)

这样我们再执行看到的结果就是这样了：

这里有一点需要注意，如果你 在jupyter当中运行是看不到这样的结果的 。因为jupyter自身是一个进程，对于jupyter当中的cell而言，它一直是有用户级线程存活的，所以进程不会退出。所以想要看到这样的效果，只能通过命令行执行Python文件。

如果我们想要等待这个子线程结束，就必须通过join方法。另外，为了预防子线程锁死一直无法退出的情况，我们还可以 在joih当中设置timeout ，即最长等待时间，当等待时间到达之后，将不再等待。

比如我在join当中设置的timeout等于5时，屏幕上就只会输出5个数字。

另外，如果没有设置成后台线程的话，设置timeout虽然也有用，但是 进程仍然会等待所有子线程结束 。所以屏幕上的输出结果会是这样的：

虽然主线程继续往下执行并且结束了，但是子线程仍然一直运行，直到子线程也运行结束。

关于join设置timeout这里有一个坑，如果我们只有一个线程要等待还好，如果有多个线程，我们用一个循环将它们设置等待的话。那么 主线程一共会等待N * timeout的时间 ，这里的N是线程的数量。因为每个线程计算是否超时的开始时间是上一个线程超时结束的时间，它会等待所有线程都超时，才会一起终止它们。

比如我这样创建3个线程：

ths = [] for i in range(3): t = threading.Thread(target=loop, name='LoopThread' + str(i), args=(10, ), daemon=True) ths.append(t) for t in ths: t.start() for t in ths: t.join(2)

最后屏幕上输出的结果是这样的：

所有线程都存活了6秒。

总结

在今天的文章当中，我们一起简单了解了 操作系统当中线程和进程的概念 ，以及Python当中如何创建一个线程，以及关于创建线程之后的相关使用。

多线程在许多语言当中都是至关重要的，许多场景下必定会使用到多线程。比如 web后端，比如爬虫，再比如游戏开发 以及其他所有需要涉及开发ui界面的领域。因为凡是涉及到ui，必然会需要一个线程单独渲染页面，另外的线程负责准备数据和执行逻辑。因此，多线程是专业程序员绕不开的一个话题，也是一定要掌握的内容之一。

㈡ Python什么情况创建多线程，什么情况创建多进程

计算密集型，创建多进程；IO密集型，创建多线程。

㈢ python3 创建线程时不用args传参，执行线程时为什么不是同时执行

在Python多线程下，每个线程的执行方式：
1、获取GIL
2、执行代码直到sleep或者是python虚拟机将其挂起。
3、释放GIL

可见，某个线程想要执行，必须先拿到GIL，我们可以把GIL看作是“通行证”，并且在一个python进程中，GIL只有一个。拿不到通行证的线程，就不允许进入CPU执行。

在Python2.x里，GIL的释放逻辑是当前线程遇见IO操作或者ticks计数达到100（ticks可以看作是Python自身的一个计数器，专门做用于GIL，每次释放后归零，这个计数可以通过
sys.setcheckinterval 来调整），进行释放。

而每次释放GIL锁，线程进行锁竞争、切换线程，会消耗资源。并且由于GIL锁存在，python里一个进程永远只能同时执行一个线程(拿到GIL的线程才能执行)，这就是为什么在多核CPU上，python的多线程效率并不高。

那么是不是python的多线程就完全没用了呢？
在这里我们进行分类讨论：
1、CPU密集型代码(各种循环处理、计数等等)，在这种情况下，由于计算工作多，ticks计数很快就会达到阈值，然后触发GIL的释放与再竞争（多个线程来回切换当然是需要消耗资源的），所以python下的多线程对CPU密集型代码并不友好。

2、IO密集型代码(文件处理、网络爬虫等)，多线程能够有效提升效率(单线程下有IO操作会进行IO等待，造成不必要的时间浪费，而开启多线程能在线程A等待时，自动切换到线程B，可以不浪费CPU的资源，从而能提升程序执行效率)。所以python的多线程对IO密集型代码比较友好。

而在python3.x中，GIL不使用ticks计数，改为使用计时器（执行时间达到阈值后，当前线程释放GIL），这样对CPU密集型程序更加友好，但依然没有解决GIL导致的同一时间只能执行一个线程的问题，所以效率依然不尽如人意。

请注意：多核多线程比单核多线程更差，原因是单核下多线程，每次释放GIL，唤醒的那个线程都能获取到GIL锁，所以能够无缝执行，但多核下，CPU0释放GIL后，其他CPU上的线程都会进行竞争，但GIL可能会马上又被CPU0拿到，导致其他几个CPU上被唤醒后的线程会醒着等待到切换时间后又进入待调度状态，这样会造成线程颠簸(thrashing)，导致效率更低

回到最开始的问题：经常我们会听到老手说：“python下想要充分利用多核CPU，就用多进程”，原因是什么呢？

原因是：每个进程有各自独立的GIL，互不干扰，这样就可以真正意义上的并行执行，所以在python中，多进程的执行效率优于多线程(仅仅针对多核CPU而言)。

所以在这里说结论：多核下，想做并行提升效率，比较通用的方法是使用多进程，能够有效提高执行效率

㈣书声琅琅教育旗下智圭谷：如何在Python中实现多线程

python主要是通过thread和threading这两个模块来实现多线程支持。
python的thread模块是比较底层的模块，python的threading模块是对thread做了一些封装，可以更加方便的被使用。但是python（cpython）由于GIL的存在无法使用threading充分利用CPU资源，如果想充分发挥多核CPU的计算能力需要使用multiprocessing模块(Windows下使用会有诸多问题)。
python3.x中已经摒弃了Python2.x中采用函数式thread模块中的start_new_thread()函数来产生新线程方式。python3.x中通过threading模块创建新的线程有两种方法：
1、通过threading.Thread(Target=executable Method)-即传递给Thread对象一个可执行方法（或对象）
2、继承threading.Thread定义子类并重写run()方法。第二种方法中，唯一必须重写的方法是run()。
了解更多python知识,0基础新手python在线学习就上智圭谷-书声琅琅教育旗下高端IT教育品牌,专注python语言领域

㈤ Python多线程是什么意思

简单地说就是作为可能是仅有的支持多线程的解释型语言（perl的多线程是残疾，PHP没有多线程），Python的多线程是有compromise的，在任意时间只有一个Python解释器在解释Python bytecode。
UPDATE：如评论指出，Ruby也是有thread支持的，而且至少Ruby MRI是有GIL的。
如果你的代码是CPU密集型，多个线程的代码很有可能是线性执行的。所以这种情况下多线程是鸡肋，效率可能还不如单线程因为有context switch
但是：如果你的代码是IO密集型，多线程可以明显提高效率。例如制作爬虫（我就不明白为什么Python总和爬虫联系在一起…不过也只想起来这个例子…），绝大多数时间爬虫是在等待socket返回数据。这个时候C代码里是有release GIL的，最终结果是某个线程等待IO的时候其他线程可以继续执行。
反过来讲：你就不应该用Python写CPU密集型的代码…效率摆在那里…
如果确实需要在CPU密集型的代码里用concurrent，就去用multiprocessing库。这个库是基于multi process实现了类multi thread的API接口，并且用pickle部分地实现了变量共享。
再加一条，如果你不知道你的代码到底算CPU密集型还是IO密集型，教你个方法：
multiprocessing这个mole有一个mmy的sub mole，它是基于multithread实现了multiprocessing的API。
假设你使用的是multiprocessing的Pool，是使用多进程实现了concurrency
from multiprocessing import Pool
如果把这个代码改成下面这样，就变成多线程实现concurrency
from multiprocessing.mmy import Pool
两种方式都跑一下，哪个速度快用哪个就行了。
UPDATE:
刚刚才发现concurrent.futures这个东西，包含ThreadPoolExecutor和ProcessPoolExecutor，可能比multiprocessing更简单

㈥ Python中进程与线程的区别是什么

Num01–>线程

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

一个线程指的是进程中一个单一顺序的控制流。

一个进程中可以并发多条线程，每条线程并行执行不同的任务。

Num02–>进程

进程就是一个程序在一个数据集上的一次动态执行过程。

进程有以下三部分组成：

1，程序：我们编写的程序用来描述进程要完成哪些功能以及如何完成。
2，数据集：数据集则是程序在执行过程中需要的资源，比如图片、音视频、文件等。
3，进程控制块：进程控制块是用来记录进程的外部特征，描述进程的执行变化过程，系统可以用它来控制和管理进程，它是系统感知进程存在的唯一标记。

Num03–>进程和线程的区别：

1、运行方式不同：

进程不能单独执行，它只是资源的集合。

进程要操作CPU，必须要先创建一个线程。

所有在同一个进程里的线程，是同享同一块进程所占的内存空间。

2，关系

进程中第一个线程是主线程，主线程可以创建其他线程；其他线程也可以创建线程；线程之间是平等的。

进程有父进程和子进程，独立的内存空间，唯一的标识符：pid。

3，速度

启动线程比启动进程快。

运行线程和运行进程速度上是一样的，没有可比性。

线程共享内存空间，进程的内存是独立的。

4，创建

父进程生成子进程，相当于复制一份内存空间，进程之间不能直接访问

创建新线程很简单，创建新进程需要对父进程进行一次复制。

一个线程可以控制和操作同级线程里的其他线程，但是进程只能操作子进程。

5，交互

同一个进程里的线程之间可以直接访问。

两个进程想通信必须通过一个中间代理来实现。

python进程创建线程

与python进程创建线程相关的资讯