python函数内进程 python进程process函数

python哪个函数启动进程和关闭进程

任何一种编程语言，启动进程和关闭进程都是跟操作系统相关的操作，python中与操作系统打交道的话，推荐使用os模块。

os.system() 函数可以启动一个进程，执行完之后返回状态码。

os.fork() 复制一个进程，如果是子进程返回0，如果是父进程返回子进程的pid，使用这个函数的时候，建议你学习一下linux编程的知识。

os.popen 以管道的方式创建进程。

os.spawnl 也可以创建进程，并能指定环境变量。

os.kill(pid, sig) 关闭一个进程，pid是进程号，sig是信号。与fork配合使用，例如你刚才用fork创建了一个子进程，它的pid是11990， 那么调用

os.kill( 11990, signal.CTRL_BREAK_EVENT)

就以ctrl+c的方式杀死了这个进程。

另外还有一个模块multiprocessing，这个模块封装了很多创建进程和进程间通信的操作，可以让你发挥多核的威力。

相关问答

Q1: Python中的进程是什么

什么是进程

进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。

狭义定义：进程是正在运行的程序的实例（an instance of a computer program that is being executed）。

广义定义：进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是操作系统动态执行的基本单元，在传统的操作系统中，进程既是基本的分配单元，也是基本的执行单元。

进程的概念主要有两点：第一，进程是一个实体。每一个进程都有它自己的地址空间，一般情况下，包括文本区域（text region）、数据区域（data region）和堆栈（stack region）。文本区域存储处理器执行的代码；数据区域存储变量和进程执行期间使用的动态分配的内存；堆栈区域存储着活动过程调用的指令和本地变量。第二，进程是一个“执行中的程序”。程序是一个没有生命的实体，只有处理器赋予程序生命时（操作系统执行之），它才能成为一个活动的实体，我们称其为进程。

相关推荐：《Python视频教程》

程序和进程的关系

编写完毕的代码，在没有运?的时候，称之为程序。

正在运行着的代码，就成为进程。

进程除了包含代码以外还有需要运行的环境等所以和程序是有区别的。

相关推荐：

Python中的多进程是什么

Q2: python中的进程-实战部分

如果想了解进程 可以先看一下这一篇 python中的进程-理论部分

python中的多线程无法利用多核优势，如果想要充分地使用多核CPU的资源（os.cpu_count()查看），在python中大部分情况需要使用多进程。Python提供了multiprocessing。

multiprocessing模块用来开启子进程，并在子进程中执行我们定制的任务（比如函数），该模块与多线程模块threading的编程接口类似。

　 multiprocessing模块的功能众多：支持子进程、通信和共享数据、执行不同形式的同步，提供了Process、Queue、Pipe、Lock等组件。

需要再次强调的一点是：与线程不同，进程没有任何共享状态，进程修改的数据，改动仅限于该进程内。

创建进程的类 ：

参数介绍：

group参数未使用，值始终为None

target表示调用对象，即子进程要执行的任务

args表示调用对象的位置参数元组，args=(1,2,'tiga',)

kwargs表示调用对象的字典,kwargs={'name':'tiga','age':18}

name为子进程的名称

方法介绍：

p.start()：启动进程，并调用该子进程中的p.run()

p.run():进程启动时运行的方法，正是它去调用target指定的函数，我们自定义类的类中一定要实现该方法

p.terminate():强制终止进程p，不会进行任何清理操作，如果p创建了子进程，该子进程就成了僵尸进程，使用该方法需要特别小心这种情况。如果p还保存了一个锁那么也将不会被释放，进而导致死锁

p.is_alive():如果p仍然运行，返回True

p.join([timeout]):主线程等待p终止（强调：是主线程处于等的状态，而p是处于运行的状态）。timeout是可选的超时时间，需要强调的是，p.join只能join住start开启的进程，而不能join住run开启的进程

属性介绍：

注意：在windows中Process()必须放到# if __name__ == '__main__':下

创建并开启子进程的两种方式

方法一:

方法二：

有了join，程序不就是串行了吗？？？

terminate与is_alive

name与pid

Q3: python 多进程

基于官方文档：

日乐购，刚才看到的一个博客，写的都不太对，还是基于官方的比较稳妥

我就是喜欢抄官方的，哈哈

通常我们使用Process实例化一个进程，并调用 他的 start() 方法启动它。

这种方法和 Thread 是一样的。

上图中，我写了 p.join() 所以主进程是 等待 子进程执行完后，才执行 print("运行结束")

否则就是反过来了（这个不一定，看你的语句了，顺序其实是随机的）例如：

主进加个 sleep

所以不加join() ,其实子进程和主进程是各干各的，谁也不等谁。都执行完后，文件运行就结束了

上面我们用了 os.getpid() 和 os.getppid() 获取 当前进程，和父进程的id

下面就讲一下，这两个函数的用法：

os.getpid()

返回当前进程的id

os.getppid()

返回父进程的id。 父进程退出后，unix 返回初始化进程（1）中的一个

windows返回相同的id (可能被其他进程使用了)

这也就解释了，为啥我上面 的程序运行多次， 第一次打印的parentid 都是 14212 了。

而子进程的父级 process id 是调用他的那个进程的 id ： 1940

视频笔记：

多进程：使用大致方法：

参考： 进程通信（pipe和queue）

pool.map （函数可以有return 也可以共享内存或queue） 结果直接是个列表

poll.apply_async() （同map,只不过是一个进程，返回结果用 xx.get() 获得）

报错：

参考 ：

把 pool = Pool() 放到 if name == " main ": 下面初始化搞定。

结果：

这个肯定有解释的

测试多进程计算效果：

进程池运行：

结果：

普通计算：

我们同样传入 1 2 10 三个参数测试：

其实对比下来开始快了一半的；

我们把循环里的数字去掉一个 0；

单进程：

多进程：

两次测试 单进程/进程池 分别为 0.669 和 0.772 几乎成正比的。

问题 二：

视图：

post 视图里面

Music 类：

直接报错：

写在 类里面也 在函数里用 self.pool 调用也不行，也是相同的错误。

最后 把 pool = Pool 直接写在 search 函数里面，奇迹出现了：

前台也能显示搜索的音乐结果了

总结一点，进程这个东西，最好 写在 直接运行的函数里面，而不是 一个函数跳来跳去。因为最后可能 是在子进程的子进程运行的，这是不许的，会报错。

还有一点，多进程运行的函数对象，不能是 lambda 函数。也许lambda 虚拟，在内存？？

使用 pool.map 子进程 函数报错，导致整个 pool 挂了:

参考：

主要你要，对函数内部捕获错误，而不能让异常抛出就可以了。

关于map 传多个函数参数

我一开始，就是正常思维，多个参数，搞个元祖，让参数一一对应不就行了：

报错：

参考：

普通的 process 当让可以穿多个参数，map 却不知道咋传的。

apply_async 和map 一样，不知道咋传的。

最简单的方法：

使用 starmap 而不是 map

结果：

子进程结束

1.8399453163146973

成功拿到结果了

关于map 和 starmap 不同的地方看源码：

关于apply_async() ,我没找到多参数的方法，大不了用 一个迭代的 starmap 实现。哈哈

关于 上面源码里面有 itertools.starmap

itertools 用法参考：

有个问题，多进程最好不要使用全部的 cpu , 因为这样可能影响其他任务，所以 在进程池 添加 process 参数 指定，cpu 个数：

上面就是预留了 一个cpu 干其他事的

后面直接使用 Queue 遇到这个问题：

解决：

Manager().Queue() 代替 Queue()

因为 queue.get() 是堵塞型的，所以可以提前判断是不是 空的，以免堵塞进程。比如下面这样：

使用 queue.empty() 空为True

Q4: Python：进程(threading)

这里是自己写下关于 Python 跟进程相关的 threading 模块的一点笔记python函数内进程，跟有些跟 Linux 调用挺像的，有共通之处。

直接传入

继承 Thread 重写 run 方法

threading.Thread(group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None)

group 线程组，未实现

start() 线程就绪

join([timeout]) 阻塞其他线程，直到调用这方法的进程结束或时间到达

RuntimeError: cannot join thread before it is started

get/setName(name) 获取/设置线程名。

isAlive() 返回线程是否在运行。

is/setDaemon(bool): 获取/设置是后台线程（默认前台线程（False））。（在start之前设置）

The entire Python program exits when no alive non-daemon threads are left.

没有非后台进程运行，Python 就退出。

主线程执行完毕后，后台线程不管是成功与否，主线程均停止

t.start()

t.join()

start() 后 join() 会顺序执行，失去线程意义

Lock属于全局，Rlock属于线程（R的意思是可重入，线程用Lock的话会死锁，来看例子）

acquire(blocking=True, timeout=-1) 申请锁，返回申请的结果

release() 释放锁，没返回结果

可以在构造时传入rlock lock实例，不然自己生成一个。

acquire([timeout])/release(): 与lock rlock 相同

wait([timeout]): 调用这个方法将使线程进入等待池，并释放锁。调用方法前线程必须已获得锁定，否则将抛出异常。

notify(): 调用这个方法将从等待池挑选一个线程并通知，收到通知的线程将自动调用acquire()尝试获得锁定（进入锁定池）python函数内进程；其他线程仍然在等待池中。调用这个方法不会释放锁定。调用方法前线程必须已获得锁定，否则将抛出异常。

notifyAll(): 调用这个方法将通知等待池中所有的线程，这些线程都将进入锁定池尝试获得锁定。调用这个方法不会释放锁定。使用前线程必须已获得锁定，否则将抛出异常。

threading.Semaphore(value=1)

acquire(blocking=True, timeout=None)

资源数大于0，减一并返回，等于0时等待，blocking为False不阻塞进程

返回值是申请结果

release()

资源数加1

事件内置python函数内进程了一个初始为False的标志

is_set() 返回内置标志的状态

set() 设为True

clear() 设为False

wait(timeout=None) 阻塞线程并等待，为真时返回。返回值只会在等待超时时为False，其他情况为True

threading.Timer(interval, function, args=None, kwargs=None)

第一个参数是时间间隔，单位是秒，整数或者浮点数，负数不会报错直接执行不等待

可以用cancel() 取消

threading.Barrier(parties, action=None, timeout=None)

调用的进程数目达到第一个设置的参数就唤醒全部进程

wait(timeout=None)

reset() 重置，等待中的进程收到 BrokenBarrierError 错误

Q5: 一篇文章带你深度解析Python线程和进程

使用Python中的线程模块，能够同时运行程序的不同部分，并简化设计。如果你已经入门Python，并且想用线程来提升程序运行速度的话，希望这篇教程会对你有所帮助。

线程与进程

什么是进程

进程是系统进行资源分配和调度的一个独立单位 进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位。每个进程都有自己的独立内存空间，不同进程通过进程间通信来通信。由于进程比较重量，占据独立的内存，所以上下文进程间的切换开销（栈、寄存器、虚拟内存、文件句柄等）比较大，但相对比较稳定安全。

什么是线程

CPU调度和分派的基本单位 线程是进程的一个实体，是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。线程间通信主要通过共享内存，上下文切换很快，资源开销较少，但相比进程不够稳定容易丢失数据。

进程与线程的关系图

线程与进程的区别：

进程

现实生活中，有很多的场景中的事情是同时进行的，比如开车的时候 手和脚共同来驾驶 汽车 ，比如唱歌跳舞也是同时进行的，再比如边吃饭边打电话；试想如果我们吃饭的时候有一个领导来电，我们肯定是立刻就接听了。但是如果你吃完饭再接听或者回电话，很可能会被开除。

注意：

多任务的概念

什么叫 多任务 呢？简单地说，就是操作系统可以同时运行多个任务。打个比方，你一边在用浏览器上网，一边在听MP3，一边在用Word赶作业，这就是多任务，至少同时有3个任务正在运行。还有很多任务悄悄地在后台同时运行着，只是桌面上没有显示而已。

现在，多核CPU已经非常普及了，但是，即使过去的单核CPU，也可以执行多任务。由于CPU执行代码都是顺序执行的，那么，单核CPU是怎么执行多任务的呢？

答案就是操作系统轮流让各个任务交替执行，任务1执行0.01秒，切换到任务2，任务2执行0.01秒，再切换到任务3，执行0.01秒，这样反复执行下去。表面上看，每个任务都是交替执行的，但是，由于CPU的执行速度实在是太快了，我们感觉就像所有任务都在同时执行一样。

真正的并行执行多任务只能在多核CPU上实现，但是，由于任务数量远远多于CPU的核心数量，所以，操作系统也会自动把很多任务轮流调度到每个核心上执行。 其实就是CPU执行速度太快啦！以至于我们感受不到在轮流调度。

并行与并发

并行（Parallelism）

并行：指两个或两个以上事件（或线程）在同一时刻发生，是真正意义上的不同事件或线程在同一时刻，在不同CPU资源呢上（多核），同时执行。

特点

并发（Concurrency）

指一个物理CPU(也可以多个物理CPU) 在若干道程序（或线程）之间多路复用，并发性是对有限物理资源强制行使多用户共享以提高效率。

特点

multiprocess.Process模块

process模块是一个创建进程的模块，借助这个模块，就可以完成进程的创建。

语法：Process([group [, target [, name [, args [, kwargs]]]]])

由该类实例化得到的对象，表示一个子进程中的任务（尚未启动）。

注意：1. 必须使用关键字方式来指定参数；2. args指定的为传给target函数的位置参数，是一个元祖形式，必须有逗号。

参数介绍：

group：参数未使用，默认值为None。

target：表示调用对象，即子进程要执行的任务。

args：表示调用的位置参数元祖。

kwargs：表示调用对象的字典。如kwargs = {'name':Jack, 'age':18}。

name：子进程名称。

代码：

除了上面这些开启进程的方法之外，还有一种以继承Process的方式开启进程的方式：

通过上面的研究，我们千方百计实现了程序的异步，让多个任务可以同时在几个进程中并发处理，他们之间的运行没有顺序，一旦开启也不受我们控制。尽管并发编程让我们能更加充分的利用IO资源，但是也给我们带来了新的问题。

当多个进程使用同一份数据资源的时候，就会引发数据安全或顺序混乱问题，我们可以考虑加锁，我们以模拟抢票为例，来看看数据安全的重要性。

加锁可以保证多个进程修改同一块数据时，同一时间只能有一个任务可以进行修改，即串行的修改。加锁牺牲了速度，但是却保证了数据的安全。

因此我们最好找寻一种解决方案能够兼顾：1、效率高（多个进程共享一块内存的数据）2、帮我们处理好锁问题。

mutiprocessing模块为我们提供的基于消息的IPC通信机制：队列和管道。队列和管道都是将数据存放于内存中 队列又是基于（管道+锁）实现的，可以让我们从复杂的锁问题中解脱出来， 我们应该尽量避免使用共享数据，尽可能使用消息传递和队列，避免处理复杂的同步和锁问题，而且在进程数目增多时，往往可以获得更好的可获展性（ 后续扩展该内容 ）。

线程

Python的threading模块

Python 供了几个用于多线程编程的模块，包括 thread, threading 和 Queue 等。thread 和 threading 模块允许程序员创建和管理线程。thread 模块 供了基本的线程和锁的支持，而 threading 供了更高级别，功能更强的线程管理的功能。Queue 模块允许用户创建一个可以用于多个线程之间 共享数据的队列数据结构。

python创建和执行线程

创建线程代码

1. 创建方法一:

2. 创建方法二:

进程和线程都是实现多任务的一种方式，例如：在同一台计算机上能同时运行多个QQ（进程),一个QQ可以打开多个聊天窗口（线程）。资源共享：进程不能共享资源，而线程共享所在进程的地址空间和其他资源，同时，线程有自己的栈和栈指针。所以在一个进程内的所有线程共享全局变量，但多线程对全局变量的更改会导致变量值得混乱。

代码演示:

得到的结果是：

首先需要明确的一点是GIL并不是Python的特性，它是在实现Python解析器(CPython)时所引入的一个概念。就好比C++是一套语言（语法）标准，但是可以用不同的编译器来编译成可执行代码。同样一段代码可以通过CPython，PyPy，Psyco等不同的Python执行环境来执行（其中的JPython就没有GIL）。

那么CPython实现中的GIL又是什么呢？GIL全称Global Interpreter Lock为了避免误导，我们还是来看一下官方给出的解释：

主要意思为:

因此，解释器实际上被一个全局解释器锁保护着，它确保任何时候都只有一个Python线程执行。在多线程环境中，Python 虚拟机按以下方式执行:

由于GIL的存在，Python的多线程不能称之为严格的多线程。因为 多线程下每个线程在执行的过程中都需要先获取GIL，保证同一时刻只有一个线程在运行。

由于GIL的存在，即使是多线程，事实上同一时刻只能保证一个线程在运行， 既然这样多线程的运行效率不就和单线程一样了吗，那为什么还要使用多线程呢？

由于以前的电脑基本都是单核CPU，多线程和单线程几乎看不出差别，可是由于计算机的迅速发展，现在的电脑几乎都是多核CPU了，最少也是两个核心数的，这时差别就出来了：通过之前的案例我们已经知道，即使在多核CPU中，多线程同一时刻也只有一个线程在运行，这样不仅不能利用多核CPU的优势，反而由于每个线程在多个CPU上是交替执行的，导致在不同CPU上切换时造成资源的浪费，反而会更慢。即原因是一个进程只存在一把gil锁，当在执行多个线程时，内部会争抢gil锁，这会造成当某一个线程没有抢到锁的时候会让cpu等待，进而不能合理利用多核cpu资源。

但是在使用多线程抓取网页内容时，遇到IO阻塞时，正在执行的线程会暂时释放GIL锁，这时其它线程会利用这个空隙时间，执行自己的代码，因此多线程抓取比单线程抓取性能要好，所以我们还是要使用多线程的。

GIL对多线程Python程序的影响

程序的性能受到计算密集型(CPU)的程序限制和I/O密集型的程序限制影响,那什么是计算密集型和I/O密集型程序呢?

计算密集型：要进行大量的数值计算，例如进行上亿的数字计算、计算圆周率、对视频进行高清解码等等。这种计算密集型任务虽然也可以用多任务完成，但是花费的主要时间在任务切换的时间，此时CPU执行任务的效率比较低。

IO密集型：涉及到网络请求(time.sleep())、磁盘IO的任务都是IO密集型任务，这类任务的特点是CPU消耗很少，任务的大部分时间都在等待IO操作完成（因为IO的速度远远低于CPU和内存的速度）。对于IO密集型任务，任务越多，CPU效率越高，但也有一个限度。

当然为了避免GIL对我们程序产生影响，我们也可以使用，线程锁。

LockRLock

常用的资源共享锁机制：有Lock、RLock、Semphore、Condition等，简单给大家分享下Lock和RLock。

Lock

特点就是执行速度慢，但是保证了数据的安全性

RLock

使用锁代码操作不当就会产生死锁的情况。

什么是死锁

死锁：当线程A持有独占锁a，并尝试去获取独占锁b的同时，线程B持有独占锁b，并尝试获取独占锁a的情况下，就会发生AB两个线程由于互相持有对方需要的锁，而发生的阻塞现象，我们称为死锁。即死锁是指多个进程因竞争资源而造成的一种僵局，若无外力作用，这些进程都将无法向前推进。

所以，在系统设计、进程调度等方面注意如何不让这四个必要条件成立，如何确定资源的合理分配算法，避免进程永久占据系统资源。

死锁代码

python线程间通信

如果各个线程之间各干各的，确实不需要通信，这样的代码也十分的简单。但这一般是不可能的，至少线程要和主线程进行通信，不然计算结果等内容无法取回。而实际情况中要复杂的多，多个线程间需要交换数据，才能得到正确的执行结果。

python中Queue是消息队列，提供线程间通信机制，python3中重名为为queue，queue模块块下提供了几个阻塞队列，这些队列主要用于实现线程通信。

在 queue 模块下主要提供了三个类，分别代表三种队列，它们的主要区别就在于进队列、出队列的不同。

简单代码演示

此时代码会阻塞，因为queue中内容已满，此时可以在第四个queue.put('苹果')后面添加timeout，则成为 queue.put('苹果'，timeout=1)如果等待1秒钟仍然是满的就会抛出异常，可以捕获异常。

同理如果队列是空的，无法获取到内容默认也会阻塞，如果不阻塞可以使用queue.get_nowait()。

在掌握了 Queue 阻塞队列的特性之后，在下面程序中就可以利用 Queue 来实现线程通信了。

下面演示一个生产者和一个消费者，当然都可以多个

使用queue模块，可在线程间进行通信，并保证了线程安全。

协程

协程，又称微线程，纤程。英文名Coroutine。

协程是python个中另外一种实现多任务的方式，只不过比线程更小占用更小执行单元（理解为需要的资源）。为啥说它是一个执行单元，因为它自带CPU上下文。这样只要在合适的时机， 我们可以把一个协程 切换到另一个协程。只要这个过程中保存或恢复 CPU上下文那么程序还是可以运行的。

通俗的理解：在一个线程中的某个函数，可以在任何地方保存当前函数的一些临时变量等信息，然后切换到另外一个函数中执行，注意不是通过调用函数的方式做到的，并且切换的次数以及什么时候再切换到原来的函数都由开发者自己确定。

在实现多任务时，线程切换从系统层面远不止保存和恢复 CPU上下文这么简单。操作系统为了程序运行的高效性每个线程都有自己缓存Cache等等数据，操作系统还会帮你做这些数据的恢复操作。所以线程的切换非常耗性能。但是协程的切换只是单纯的操作CPU的上下文，所以一秒钟切换个上百万次系统都抗的住。

greenlet与gevent

为了更好使用协程来完成多任务，除了使用原生的yield完成模拟协程的工作，其实python还有的greenlet模块和gevent模块，使实现协程变的更加简单高效。

greenlet虽说实现了协程，但需要我们手工切换，太麻烦了，gevent是比greenlet更强大的并且能够自动切换任务的模块。

其原理是当一个greenlet遇到IO(指的是input output 输入输出，比如网络、文件操作等)操作时，比如访问网络，就自动切换到其他的greenlet，等到IO操作完成，再在适当的时候切换回来继续执行。

模拟耗时操作：

如果有耗时操作也可以换成，gevent中自己实现的模块，这时候就需要打补丁了。

使用协程完成一个简单的二手房信息的爬虫代码吧！

以下文章来源于Python专栏 ，作者宋宋

文章链接：

关于python函数内进程和python进程process函数的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。