python函数进程管理 python3进程管理

python并发编程-进程池

在利用Python进行系统管理的时候，特别是同时操作多个文件目录，或者远程控制多台主机，并行操作可以节约大量的时间。多进程是实现并发的手段之一，需要注意的问题是：

例如当被操作对象数目不大时，可以直接利用multiprocessing中的Process动态成生多个进程，十几个还好，但如果是上百个，上千个。。。手动的去限制进程数量却又太过繁琐，此时可以发挥进程池的功效。

我们就可以通过维护一个进程池来控制进程数目，比如httpd的进程模式，规定最小进程数和最大进程数..

ps： 对于远程过程调用的高级应用程序而言，应该使用进程池，Pool可以提供指定数量的进程，供用户调用，当有新的请求提交到pool中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求；但如果池中的进程数已经达到规定最大值，那么该请求就会等待，直到池中有进程结束，就重用进程池中的进程。

创建进程池的类：如果指定numprocess为3，则进程池会从无到有创建三个进程，然后自始至终使用这三个进程去执行所有任务，不会开启其他进程

参数介绍：

方法介绍：

主要方法：

其他方法（了解部分）

应用：

发现：并发开启多个客户端，服务端同一时间只有3个不同的pid，干掉一个客户端，另外一个客户端才会进来，被3个进程之一处理

回调函数：

需要回调函数的场景：进程池中任何一个任务一旦处理完了，就立即告知主进程：我好了额，你可以处理我的结果了。主进程则调用一个函数去处理该结果，该函数即回调函数

我们可以把耗时间（阻塞）的任务放到进程池中，然后指定回调函数（主进程负责执行），这样主进程在执行回调函数时就省去了I/O的过程，直接拿到的是任务的结果。

如果在主进程中等待进程池中所有任务都执行完毕后，再统一处理结果，则无需回调函数

相关问答

Q1: python同时打开几个程序默认运行哪一个

操作系统的作用

隐藏丑陋复杂的硬件接口，提供良好的抽象接口

管理、调度进程，并且将多个进程对硬件的竞争变得有序

2. 多道技术产生背景

针对单核，实现并发

现在的主机一般是多核，那么每个核都会利用多道技术

有 4 个 cpu，运行于 cpu1 的某个程序遇到 io 阻塞，会等到 io 结束再重新调度

会被调度到 4 个 cpu 中的任意一个，具体由操作系统调度算法决定

3. 多道技术空间上的复用python函数进程管理：如内存中同时有多道程序

4. 多道技术时间上的复用

复用一个 cpu 的时间片

注意，遇到 io 切，占用 cpu 时间过长也切

核心在于切之前将进程的状态保存下来

这样才能保证下次切换回来时，能基于上次切走的位置继续运行

进程的概念

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

进程是操作系统动态执行的基本单元

在传统的操作系统中，进程既是基本的分配单元，也是基本的执行单元

进程与程序的区别

程序是指令和数据的有序集合，是一个静态的概念。程序可以作为一种软件资料长期存在，是永久的

进程是程序在处理机上的一次执行过程,它是一个动态的概念。进程是有一定生命期的，是暂时的

5. 注意python函数进程管理：同一个程序执行两次，就会在操作系统中出现两个进程。所以可以同时运行一个软件，分别做不同的事情也不会混乱，比如可以打开两个Pycharm做不同的事

6. 进程调度

要想多个进程交替运行，操作系统必须对这些进程进行调度

这个调度也不是随即进行的，而是需要遵循一定的法则

由此就有了进程的调度算法：先来先服务调度算法、短作业优先调度算法、时间片轮转法、多级反馈队列

并行和并发

并行是指在一个时间点上，有多个进程在被 cpu 计算，比如赛跑，两个人都在不停的往前跑

并发是指资源有限的情况下，在一个时间段上，有多个进程在被 cpu 计算，交替轮流使用资源

并行与并发的区别

并行是从微观上，也就是在一个精确的时间片刻，有不同的程序在执行，这就要求必须有多个处理器

并发是从宏观上，在一个时间段上可以看出是同时执行的，比如一个服务器同时处理多个 session

进程的三状态

在程序运行的过程中，由于被操作系统的调度算法控制，程序会进入几个状态

就绪

运行

阻塞

2. 举例说明什么是 argv，什么是阻塞

import sys

print(sys.argv)

# 运行结果：

['G:/course_select/进程的概念.py']

# argv 指参数

# sys.argv 是 Python 解释器在运行的时候传递进来的参数

# 首先在cmd输入以下信息：

python G:/course_select/进程的概念.py

# 打印结果：

['G:/course_select/进程的概念.py']

# 然后在cmd中切换路径到G盘，接着输入 python course_select/进程的概念.py

# 打印结果：

['course_select/进程的概念.py']

# 接着，再在cmd中输入：python course_select/进程的概念.py 123 abc

# 打印结果：

['course_select/进程的概念.py', '123', 'abc']

# 因此，以下程序不能在编辑器里运行，只能在 cmd 里面使用 Python 运行本文件

# 然后要在后面加上 aaa bbb

# 就像上面的 python course_select/进程的概念.py 123 abc 一样

if sys.argv[1] == "aaa" and sys.argv[2] == "bbb":

print("登录成功")

else:

print("登录失败")

exit()

print(666)

# 而如果使用input(),其实就是一种阻塞

3. 进程的三状态图

234e05553b4315faa53410e4072c9a16.png

同步异步

同步：形象的说，一件事的执行必须依赖另一件事的结束，强调的是顺序性

异步： 形象的说，两件事情可以同时进行

注意：同步异步和并行、并发没关系

阻塞：等待，比如 input sleep recv accept recvfrom

非阻塞：不等待，start/terminate 都是非阻塞的

阻塞与非阻塞主要是从程序（线程）等待消息通知时的状态角度来说的

可以分为四类：

同步阻塞

异步阻塞

同步非阻塞

异步非阻塞

start/terminate 都是非阻塞的

进程模块

跟进程相关的基本都在这个模块里：multiprocessing

父进程与子进程的对比分析

父进程，比如运行本文件

子进程，运行 Process(target=func).start()

父进程与子进程数据隔离

主进程等待子进程结束之后再结束

子进程和主进程之间默认是异步的

from multiprocessing import Process

import time

def func():

time.sleep(1)

print(666)

if __name__ == "__main__":

# 开启了一个新的进程，在这个新的进程里执行的 func()

Process(target=func).start()

time.sleep(1)

# 主进程

print(777)

# 777

# 666

# 运行结果仔细观察发现有异步的效果

# 也就是说，主进程和新的进程同时执行

3. 上面的示例中为什么要有 if __name__ == "__main__"？其实这是 windows 操作系统开启子进程的方式问题

4. 继续深入

import time

import os

from multiprocessing import Process

def func():

time.sleep(1)

print(666, os.getpid(), os.getppid())

if __name__ == "__main__":

# 代码执行到这里并不代表开启了子进程

p = Process(target=func)

# 开启了一个子进程，并执行func()

p.start()

time.sleep(1)

print(777, os.getpid(), os.getppid())

# 主进程运行的结果

777 12340 1636

# 子进程运行的结果

666 7604 12340

# 由上面两行结果可以得出：

# 利用 os.getpid() 证明两个进程不一样

# 另外每次运行，os.getpid() 结果都不一样

# 但是，12340 是主进程的 id，7604 是子进程的 id

# 1636 是 Pycharm 的 id，排列特点不变

5. 开启多个相同的子进程示例

import time

import os

from multiprocessing import Process

def func():

time.sleep(3)

print(666, os.getpid(), os.getppid())

if __name__ == "__main__":

for i in range(10):

p = Process(target=func)

p.start()

time.sleep(1)

print(777, os.getpid(), os.getppid())

# 这里需要注意一点：Python 程序一直都是逐行执行

# 但是因为这里设置了时间延迟，因此会先执行主程序的代码

# 运行结果：

777 29006 3833 # 暂停 2s 后再有下面的结果

666 29007 29006

666 29009 29006

666 29008 29006

666 29010 29006

666 29013 29006

666 29011 29006

666 29012 29006

666 29014 29006

666 29016 29006

666 29015 29006

# 观察结果发现主进程只运行了一次

# 然后剩下的全是一个子进程重新运行的结果

# 主进程运行完不会结束，它会等子进程全部运行结束

# 注意变量 p 拿到的是最后一个子进程的 id

6. 开启多个不同的子进程示例

import time

import os

from multiprocessing import Process

def func():

time.sleep(2)

print(666, os.getpid(), os.getppid())

def func2():

print(111)

if __name__ == "__main__":

for i in range(3):

p = Process(target=func)

p.start()

for i in range(2):

p = Process(target=func2)

p.start()

time.sleep(1)

print(777, os.getpid(), os.getppid())

# 运行程序时仔细观察结果显示顺序：

111

111

777 29316 3833

666 29319 29316

666 29317 29316

666 29318 29316

7. 给子进程传参示例

from multiprocessing import Process

def func(name):

print(666, name)

if __name__ == "__main__":

p = Process(target=func,args=(777,)) # 注意是一个元组

p.start()

import time

from multiprocessing import Process

def func(num, name):

time.sleep(1)

print(num, "hello", name)

if __name__ == "__main__":

for i in range(10):

p = Process(target=func, args=(i, "abc"))

p.start()

print("主进程")

# 运行结果：

666 777

主进程

0 hello abc

2 hello abc

1 hello abc

3 hello abc

5 hello abc

4 hello abc

6 hello abc

7 hello abc

8 hello abc

9 hello abc

# 多运行几次，发现子进程并不是完全按顺序运行的

# 比如上面先出结果 2 hello abc，再出结果 1 hello abc

8. 子进程可以有返回值吗：不能有返回值，因为子进程函数中的返回值无法传递给父进程

import time

from multiprocessing import Process

def func():

time.sleep(3)

print("这是子进程,3s后才运行")

if __name__ == "__main__":

Process(target=func).start()

print("主进程")

# 运行结果：

主进程

这是子进程,3s后才运行

# 主进程会默认等待子进程结束之后才结束

# 因为父进程要负责回收子进程占用的操作系统资源

相关资源：Python多进程写入同一文件的方法_python多进程写入同意文件-其它...

文章知识点与官方知识档案匹配

Python入门技能树首页概览

194693 人正在系统学习中

点击阅读全文

打开CSDN，阅读体验更佳

Python多进程(一)进程及进程池_程序员-夏天的博客

print("主进程结束") 通过上述代码我们发现,multiprocessing.Process帮我们创建一个子进程,并且成功运行,但是我们发现,在子进程还没执行完的时候主进程就已经死了,那么这个子进程在主进程结束后就是一个孤儿进程,那么我们可以让主进程等待...

Python多进程之Process、Pool、Lock、Queue、Event、Semaphore、Pipe_大 ...

1. Python创建进程类Process python的multiprocessing模块提供了一个创建进程的类Precess,其创建有以下两种方法: 创建Process类的实例,并指向目标函数和传递参数 自定义一个类并继承Process类,重写__init__()和run()方法 ...

python两个进程同时开启只运行了一个_二十二、 深入Python的进程和线程（上篇）...

「@Author： Runsen」进程(Process)和线程(Thread)都是操作系统中的基本概念，它们之间有一些优劣和差异，那么在Python中如何使用进程和线程？CPU计算机的核心是CPU，它承担了计算机的所有计算任务，CPU就像一个工厂，时刻在运行着，而操作系统管理着计算机，负责任务的调度、资源的分配和管理。进程进程是指在系统中能独立运行并作为资源分配的基本单位，它是由一组机器指令、数据...

继续访问

python启动多个进程_Python多处理：只有一个进程正在运行

由于注释表明您希望使用初始化程序和initargs参数传递featureVector.在Unix类型的系统上,这将导致大量的性能提升(即使selLabel中只有1个项目),因为该值将使用os.fork基本上免费传递给子进程.否则,每次调用foo时,featureVector都将被父进程pickle,通过管道传递并由子进程进行unpickled.这将花费很长时间,并且基本上将序列化所有子进程,因为它...

继续访问

python多进程多线程,多个程序同时运行_陈逸飞_p的博客_pyth...

python 模块应用 开发工具 pycharm 实现方法 多任务的实现可以用进程和线程来实现 进程— 线程--- 多任务应用 多进程操作 比如下载多个文件, 利用cpu 资源 提高效率 多任务: 同一时间执行多个任务, 比如windows操作系统 执行...

python多进程单例_Python多线程处理实例详解【单进程/多进程】

python — 多线程处理 1、一个进程执行完后,继续下一个进程 root@72132server:~# cd /root/python/multiprocess/ root@72132server:~/python/multiprocess# ls multprocess.py root@72132server:~/python/multiprocess# cat multprocess...

系统编程__2__父子进程的创建和回收

系统编程 这里写的是对于小白来说更多的了解系统编程的文章，有写的不对的地方还恳请各位大佬指出错误，小编一定会多多采纳[手动多谢]。 那么，上一次我们稍微了解了一下关于系统编程的一些主要内容[没有看到的童鞋还请去上一篇文章稍微复习一下噢]。 这节课，我们先来想一想，我们为什么要学系统编程呢？原因很简单，我们要充分的利用CPU的性能，CPU和我们人类不太一样，我们人类大多数情况下，在同一时间，只能完成一件事，而CPU作为无数科学家的心血当然不会这么简单，CPU能够同时进行多个进程，这里的进程我们可以理解成任务，

继续访问

android 10 system/core无法打印log问题

1.关闭重定向 system/core/init/util.cpp --- a/init/util.cpp +++ b/init/util.cpp @@ -454,7 +454,7 @@ static void InitAborter(const char* abort_message) { // SetStdioToDevNull() must be called again in second stage init. void SetStdioToDevNull(char** argv) { ...

继续访问

Python多进程1 一个多进程实例_BBJG_001的博客

下执行,job('主进程step1###')p1=mp.Process(target=job,args=('新进程',))# 创建一个进程# 注意当只有一个参数的时候,一定要在参数后面加一个逗号,因为args需要是一个可以迭代的参量p1.start()# 开始执行新进程# p...

热门推荐 python多进程多线程,多个程序同时运行

python 多线程 多进程同时运行 多任务要求 python 基础语法 python 文件目录操作 python 模块应用 开发工具 pycharm 实现方法 多任务的实现可以用进程和线程来实现 进程— 线程---- 多任务应用 多进程操作 比如下载多个文件, 利用cpu 资源 提高效率 多任务： 同一时间执行多个任务, 比如windows操作系统 执行方式有两种( 表现形式 ) 并发 在单核cpu中: 在一段时间内交替执行多个任务, 例如单核cpu 处理多任务, 操作系统让各个任务交

继续访问

fork()函数

多进程通信 fork()函数

继续访问

（1/7）Electron教程（一）什么是 Electron，由来、适用场景 和 Electron 的环境搭建（1/7）

最近自己有个小的需求，是做一个能编辑本地特定文本的工具，需要跨平台， Windows 和 macOS，这样，如果用原生开发的话，Windows 就要用c#macOS 就要用swift，学习成本高，并且学完用处也不是很大。我本身是前端开发的，发现了这个electron能满足我的需求，跨平台运行，内部是 js 驱动的，简直就是如鱼得水。顺便把学习的经历写出来，分享需要的人，我会按标题序号渐进式地编写内容。electron。...

继续访问

fork()详解

一： fork()函数用来创建新的进程，它的特点是调用一次返回两次( 在原来的进程中返回新进程的 PID（新进程的 PID 肯定不等于 0）， 在新进程中返回为 0.) 函数原型：pid_t fork(void)python函数进程管理； pid_t getpid(); 获取当前进程的 pid 值。 pid_t getppid(); 获取当前进程的父进程 pid 值。 图一 如图一所...

继续访问

fork()函数详解

目录 1.基本了解： 2.fork函数的了解： 3.僵死进程： 1.基本了解： 一个进程，包括代码、数据和分配给进程的资源。fork 函数会新生成一个进程，调用 fork 函数的进程为父进程，新生成的进程为子进程。在父进程中返回子进程的 pid，在子进程中返回 0，失败返回-1。 为什么两个进程的fpid不同呢，这与fork函数的特性有关。fork调用的一个奇妙之处就是它仅仅被调用一次，却能够返回两次，它可能有三种不同的返回值： 1）在父进程中，fork返回新创建子进程的进程...

继续访问

Electron在Windows下的环境搭建

Electron作为一种用javascript写桌面程序的开发方式，现在已经被大众接受。下面就介绍如何在windows（win7）下快速搭建Electron开发环境。 1. nodejs 的安装 从nodejs 下载最新版本的windows安装程序进行安装，我下载的是v6.9.1，安装时一路默认即可，这个安装会把nodejs和npm配置到系统PATH中，这样在命令行的任何位置都可以直接...

继续访问

python多线程pool_Python mutiprocessing多线程池pool操作示例

本文实例讲述了Python mutiprocessing多线程池pool操作。分享给大家供大家参考，具体如下：python — mutiprocessing 多线程 pool脚本代码：root@72132server:~/python/multiprocess# lsmultiprocess_pool.py multprocess.pyroot@72132server:~/python/multi...

继续访问

最新发布 python入门开发学习笔记之守护进程

本节重点 了解守护进程的概念 本节时长需控制在5分钟内 一 守护进程 主进程创建子进程，然后将该进程设置成守护自己的进程，守护进程就好比崇祯皇帝身边的老太监，崇祯皇帝已死老太监就跟着殉葬了。 关于守护进程需要强调两点： 其一：守护进程会在主进程代码执行结束后就终止 其二：守护进程内无法再开启子进程,否则抛出异常：AssertionError: daemonic processes are not allowed to have children 如果我们有两个任务需要并发执行，那么开一个主进程和一个子进程分

继续访问

用python进行多进程编程时，只有主进程可以运行，子进程貌似没有运行是什么原因？

找了半天，原来是这个原因！这是因为multiprocessing模块在交互模式是不支持的，在 cmd 里头输入 python xxx.py 来运行起来，python函数进程管理你就可以看到子进程的执行了。

继续访问

linux中fork() 函数详解

fork入门知识 一个进程，包括代码、数据和分配给进程的资源。fork（）函数通过系统调用创建一个与原来进程几乎完全相同的进程，也就是两个进程可以做完全相同的事，但如果初始参数或者传入的变量不同，两个进程也可以做不同的事。 一个进程调用fork（）函数后，系统先给新的进程分配资源，例如存储数据和代码的空间。然后把原来的进程的所有值都复制到新的新进程中，只有少数值与原来的进程的值不同。相当于克隆了...

继续访问

Windows版 Node.js 安装详解以及Electron安装

Windows Node.js 安装详解以及Electron安装详解，示例版本：node v10.15.0/npm6.4.1 介绍： 简单的说 Node.js 就是运行在服务端的 JavaScript。 Node.js 是一个基于Chrome JavaScript 运行时建立的一个平台。 Node.js是一个事件驱动I/O服务端JavaScript环境，基于Google的V8引擎，V8引擎执...

继续访问

Electron 简介

本教程我们来学习 Electron 的基础知识，下面我们先来学习一下什么是 Electron。 Electron是什么 Electron 是是 GitHub 开发的一个开源框架。它允许使用 Node.js（作为后端）和 Chromium（作为前端）完成桌面 GUI 应用程序的开发。 Electron 可以用于构建具有 HTML、CSS、JavaScript 的跨平台桌面应用程序，它通过将 Chromium 和 node.js 合同一个运行的环境中来实现这一点，应用程序可以打包到 Mac、Windows 和

继续访问

Election的优缺点

优点 原生的接口（菜单、消息提醒、系统托盘等）。 上手难度低。能够使用react、vue等前端框架，能方便地迁移前端组件，构建出漂亮的桌面应用。 方便热更新 调试和测试方便 Electron使用node.js。因此，您可以导入Chrome应用程序中不容易使用的许多模块 Electron文档要好得多，尽管它是一个更年轻的平台 缺点 不适合开发轻量级的应用。即使一个electron的项目框架，也包含chromium内核，打包完接近200G。 相比c++开发的桌面应用，性能远远不如后者。 启动速

继续访问

[electron]终极奥义 五千字教程丢给你

前言 本文包含打包、自动更新、简易API、调试、进程通信等相关知识点，内容较多，可能会引起不适，请酌情查看（手动滑稽）。 electron 简介 electron是由Github开发，是一个用Html、css、JavaScript来构建桌面应用程序的开源库，可以打包为Mac、Windows、Linux系统下的应用。 electron是一个运行时环境，包含Node和Chromium，可以理解成把we...

继续访问

深入理解Java中的wait() 方法

使用场景 当某个线程获取到锁后，发现当前还不满足执行的条件，就可以调用对象锁的wait方法，进入等待状态。 直到某个时刻，外在条件满足了，就可以由其他线程通过调用notify()或者notifyAll()方法，来唤醒此线程。 这篇文章将侧重于讨论wait()方法对于线程状态的影响，以及被唤醒后线程的状态变更。 条件 只有已经获取锁的线程，才可以调用锁的wait方法，否则会抛出异常IllegalMonitorStateException。 比如下面的代码，A获得了锁后，主动调用wait方法释放锁和

继续访问

用Electron开发桌面应用的避坑指南(文末送书)

送一波高质量Web开发图书，送5本书籍，随你挑。抽奖规则见本文最后！抽奖规则见本文最后！抽奖规则见本文最后！如今，Electron 领域发生了重大的变革，Electron 版本更新换代极快...

继续访问

python多进程只有一个进程在执行

python两个进程同时开启只运行了一个。

Q2: Python多进程运行——Multiprocessing基础教程2

上篇文章简单介绍了multiprocessing模块，本文将要介绍进程之间的数据共享和信息传递的概念。

在多进程处理中，所有新创建的进程都会有这两个特点：独立运行，有自己的内存空间。

我们来举个例子展示一下：

这个程序的输出结果是：

在上面的程序中我们尝试在两个地方打印全局列表result的内容：

我们再用一张图来帮助理解记忆不同进程间的数据关系：

如果程序需要在不同的进程之间共享一些数据的话，该怎么做呢？不用担心，multiprocessing模块提供了Array对象和Value对象，用来在进程之间共享数据。

所谓Array对象和Value对象分别是指从共享内存中分配的ctypes数组和对象。我们直接来看一个例子，展示如何用Array对象和Value对象在进程之间共享数据：

程序输出的结果如下：

成功了！主程序和p1进程输出了同样的结果，说明程序中确实完成了不同进程间的数据共享。那么我们来详细看一下上面的程序做了什么：

在主程序中我们首先创建了一个Array对象：

向这个对象输入的第一个参数是数据类型：i表示整数，d代表浮点数。第二个参数是数组的大小，在这个例子中我们创建了包含4个元素的数组。

类似的，我们创建了一个Value对象：

我们只对Value对象输入了一个参数，那就是数据类型，与上述的方法一致。当然，我们还可以对其指定一个初始值（比如10），就像这样：

随后，我们在创建进程对象时，将刚创建好的两个对象：result和square_sum作为参数输入给进程：

在函数中result元素通过索引进行数组赋值，square_sum通过 value 属性进行赋值。

注意：为了完整打印result数组的结果，需要使用 result[:] 进行打印，而square_sum也需要使用 value 属性进行打印：

每当python程序启动时，同时也会启动一个服务器进程。随后，只要我们需要生成一个新进程，父进程就会连接到服务器并请求它派生一个新进程。这个服务器进程可以保存Python对象，并允许其他进程使用代理来操作它们。

multiprocessing模块提供了能够控制服务器进程的Manager类。所以，Manager类也提供了一种创建可以在不同流程之间共享的数据的方法。

服务器进程管理器比使用共享内存对象更灵活，因为它们可以支持任意对象类型，如列表、字典、队列、值、数组等。此外，单个管理器可以由网络上不同计算机上的进程共享。

但是，服务器进程管理器的速度比使用共享内存要慢。

让我们来看一个例子：

这个程序的输出结果是：

我们来理解一下这个程序做了什么：首先我们创建了一个manager对象

在with语句下的所有行，都是在manager对象的范围内的。接下来我们使用这个manager对象创建了列表（类似的，我们还可以用 manager.dict() 创建字典）。

最后我们创建了进程p1（用于在records列表中插入一条新的record）和p2（将records打印出来），并将records作为参数进行传递。

服务器进程的概念再次用下图总结一下：

为了能使多个流程能够正常工作，常常需要在它们之间进行一些通信，以便能够划分工作并汇总最后的结果。multiprocessing模块支持进程之间的两种通信通道：Queue和Pipe。

使用队列来回处理多进程之间的通信是一种比较简单的方法。任何Python对象都可以使用队列进行传递。我们来看一个例子：

上面这个程序的输出结果是：

我们来看一下上面这个程序到底做了什么。首先我们创建了一个Queue对象：

然后，将这个空的Queue对象输入square_list函数。该函数会将列表中的数平方，再使用 put() 方法放入队列中：

随后使用 get() 方法，将q打印出来，直至q重新称为一个空的Queue对象：

我们还是用一张图来帮助理解记忆：

一个Pipe对象只能有两个端点。因此，当进程只需要双向通信时，它会比Queue对象更好用。

multiprocessing模块提供了 Pipe() 函数，该函数返回由管道连接的一对连接对象。 Pipe() 返回的两个连接对象分别表示管道的两端。每个连接对象都有 send() 和 recv() 方法。

我们来看一个例子：

上面这个程序的输出结果是：

我们还是来看一下这个程序到底做了什么。首先创建了一个Pipe对象：

与上文说的一样，该对象返回了一对管道两端的两个连接对象。然后使用 send() 方法和 recv() 方法进行信息的传递。就这么简单。在上面的程序中，我们从一端向另一端发送一串消息。在另一端，我们收到消息，并在收到END消息时退出。

要注意的是，如果两个进程(或线程)同时尝试从管道的同一端读取或写入管道中的数据，则管道中的数据可能会损坏。不过不同的进程同时使用管道的两端是没有问题的。还要注意，Queue对象在进程之间进行了适当的同步，但代价是增加了计算复杂度。因此，Queue对象对于线程和进程是相对安全的。

最后我们还是用一张图来示意：

Python的multiprocessing模块还剩最后一篇文章：多进程的同步与池化

敬请期待啦！

Q3: 如何使用Python的Supervisor来管理进程

在python开发中，如何使用supervisor来管理进程呢？Supervisor是什么？Supervisor是如何管理进程的，现在就跟随小编一起来看看使用python的supervisor管理经常的方法。

Supervisor可以启动、停止、重启*nix系统中的程序。也可以重启崩溃的程序。

supervisord的一个守护进程，用于将指定的进程当做子进程来运行。

supervisorctl是一个客户端程序，可以查看日志并通过统一的会话来控制进程。

看例子：

我们写了一个py脚本，用于往log文件中记录一条当前的时间。

[python]view plaincopy

1.root@ubuntu:/home/zoer#catdaemon.py

2.#!/usr/bin/envpython

3.

4.importtime

5.importos

6.time.sleep(1)

7.f=open("log",'a')

8.t=time.time()

9.f.write(str(t))

10.f.write("\n")

11.f.close()

安装过程就不说了。

安装完毕supervisor之后【将配置文件放在/etc下】。修改配置文件，在最后增加如下内容：

[program:ddd]

command=/home/zoer/daemon.py

autorestart=true

然后我们启动supervisor并启动daemon.py的执行。

[python]view plaincopy

1.root@ubuntu:/home/zoer#supervisord

2./usr/local/lib/python2.7/dist-packages/supervisor-3.0b1-py2.7.egg/supervisor/options.py:286:UserWarning:Supervisordisrunningasrootanditissearchingforitsconfigurationfileindefaultlocations(includingitscurrentworkingdirectory);youprobablywanttospecifya"-c"argumentspecifyinganabsolutepathtoaconfigurationfileforimprovedsecurity.

3.'Supervisordisrunningasrootanditissearching'

4.root@ubuntu:/home/zoer#supervisorctl

5.dddSTARTING

6.supervisorstartddd

7.ddd:ERROR(alreadystarted)

8.supervisorstopddd

9.ddd:stopped

10.supervisorstartddd

11.ddd:started

12.supervisor

从上面的例子中，看到，可以通过start或者stop命令来启动或者停止ddd这个进程。ddd这里就是我们在配置文件中增加的内容（daemon.py这个脚本）。

也可以使用restart。如下：

supervisor restart ddd

ddd: stopped

ddd: started

-------------------------------------------------------

下面我们测试一下，假设说我们手动kill掉了ddd这个进程，那么ddd会自动恢复执行吗？

为了做实验，把代码修改如下：

[python]view plaincopy

1.root@ubuntu:/home/zoer#catdaemon.py

2.#!/usr/bin/envpython

3.

4.importtime

5.importos

6.whileTrue:

7.time.sleep(1)

8.f=open("log",'a')

9.t=time.time()

10.f.write(str(t))

11.f.write("\n")

12.f.close()

通过ps可以找到这个进程的id：

[plain]view plaincopy

1.root93540.20.4109244200?S23:160:00python/home/zoer/daemon.py

2.root93950.00.04392832pts/3S+23:170:00grep--color=autodaemon

3.root@ubuntu:/home/zoer#

看下面的操作：

[plain]view plaincopy

1.root@ubuntu:/home/zoer#rmlog;touchlog;kill9354

2.root@ubuntu:/home/zoer#catlog

3.1364710712.51

4.root@ubuntu:/home/zoer#catlog

5.1364710712.51

6.1364710713.51

7.root@ubuntu:/home/zoer#catlog

8.1364710712.51

9.1364710713.51

10.root@ubuntu:/home/zoer#catlog

11.1364710712.51

12.1364710713.51

13.1364710714.52

14.root@ubuntu:/home/zoer#catlog

15.1364710712.51

16.1364710713.51

17.1364710714.52

18.1364710715.52

删除了log文件，并且重新创建。然后干掉了daemon.py的那个进程。会发现log内容又重新有新的内容了。再次ps查看进程号。

[plain]view plaincopy

1.root94290.10.4109244200?S23:180:00python/home/zoer/daemon.py

2.root94400.00.04392828pts/3S+23:190:00grep--color=autodaemon

3.root@ubuntu:/home/zoer#

会发现进程号已经变成9429了。说明supervisor已经重启了被干掉了的进程。

Q4: Python管理Windows进程

用python获得正在的运行的windows进程的有几种方式:

通过 PyWin32 包对Windows进行处理。

可以通过这个获取系统信息，但仅限于windows系统。

运行结果：

运行结果：

运行结果：

通过交互模式，使用WMI取得进程：

此方法可以跨平台，不过需要在安装 psutil 包.

以上实现一个类似top的工具。

转自

python函数进程管理的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于python3进程管理、python函数进程管理的信息别忘了在本站进行查找喔。