python结束进程

⑴ python调用OS.system结束进程问题

os.system是执行命令，是否打印取决于命令是否有返回
如果你想不让其打印 可以在命令中做手脚如： os.system('taskkill /IM dllhost.exe > NUL')

⑵ python多进程怎么判断所有进程结束

python执行ps -ef | grep XXX XXX为你的进程，当有返回值的时候，说明你的进程存在，python检查系统进程其实调用的也是linux的shell

⑶ python怎么让进程暂停

您的意思是要将进程挂起(Suspend) 而非 阻塞(Block)
如果用sleep() 进程将阻塞
假设进程下有两个线程 那么这两个线程会继续运行
要使进程挂起 可以考虑使用psutil
import psutil
p = psutil.Process(pid)
p.suspend() #挂起进程
p.resume() #恢复进程

为了证明效果 我写了一个简单的进程Process
其下有两个线程 读者Reader 和 写者Writer（简单的读者写者问题）

Process:
import threading

from time import ctime, sleep
import ThreadInReadAndWriteProblem
import multiprocessing
import os

class Process(multiprocessing.Process):

def __init__(self):
multiprocessing.Process.__init__(self) #手动实现父类
pid = os.getpid()

def run(self):
print '当前运行进程PID : %s ' %self.pid #子线程的id与父进程的pid相同 属于 同一个进程

for i in range(0,5):
r = ThreadInReadAndWriteProblem.Reader()
w = ThreadInReadAndWriteProblem.Writer()
w.start()
r.start()

print '进程阻塞'
sleep(10) #总共运行时间10秒

Reader&Writer
import threading
from time import ctime, sleep
import os

mutex = threading.Lock() #互斥锁
mutex_readercount = threading.Lock() #计数时的互斥 计算当前正在读的数目
readerCount = 0 number = 0

#不满足条件的 进入阻塞状态

class Reader(threading.Thread): #读者
def __init__(self):
threading.Thread.__init__(self) #继承父类构造函数

def run(self):
global mutex
global readerCount
#print '线程PID: %s ' %os.getpid()
while True:
mutex_readercount.acquire()
readerCount +=1
if readerCount == 1:
print '读者进程等待中，编号%s' %(self.name)
mutex.acquire() == False # 第一个需要申请

mutex_readercount.release()
print '开始读 , 读者编号 %s ,现在时间是 %s' %(self.name,ctime())
sleep(2)
print '完成读 , 读者编号 %s , 现在时间是 %s' %(self.name,ctime())

mutex_readercount.acquire()
readerCount -= 1
if readerCount == 0: #所有读者均完成
print '最后一个读者完成读 '
mutex.release()
mutex_readercount.release()

class Writer(threading.Thread): #写者
def __init__(self):
threading.Thread.__init__(self)

def run(self):
global mutex
global writerCount
#print '线程PID： %s' %os.getpid()
while True:
print '写者进程等待中 编号： %s' %(self.name)
mutex.acquire()
print '开始写 编号：%s 现在时间是： %s ' %(self.name,ctime())
sleep(5)
print '结束写 编号: %s 现在时间是 %s' %(self.name,ctime())
mutex.release()

测试程序
import ThreadInReadAndWriteProblem
import
import psutil
import Scheler
from time import ctime, sleep

def main():
p = .Process()
p.start()

sleep(3)

stop(p.pid)
print '进程挂起 %s' %ctime()
sleep(5)

wake(p.pid)
print '唤醒进程 %s' %ctime()

def stop(pid):
print '进程暂停 进程编号 %s ' %(pid)
p = psutil.Process(pid)
p.suspend()

def wake(pid):
print '进程恢复 进程编号 %s ' %(pid)
p = psutil.Process(pid)
p.resume()

if __name__ == '__main__':
main()

结果：
当前运行进程PID : 3096
写者进程等待中 编号： Thread-2
开始写 编号：Thread-2 现在时间是： Mon Nov 30 21:12:12 2015
读者进程等待中，编号Thread-1
写者进程等待中 编号： Thread-4
进程阻塞
写者进程等待中 编号： Thread-6
写者进程等待中 编号： Thread-8
写者进程等待中 编号： Thread-10
进程暂停 进程编号 3096
进程挂起 Mon Nov 30 21:12:15 2015
进程恢复 进程编号 3096
唤醒进程 Mon Nov 30 21:12:20 2015
结束写 编号: Thread-2 现在时间是 Mon Nov 30 21:12:20 2015
写者进程等待中 编号： Thread-2
开始读 , 读者编号 Thread-1 ,现在时间是 Mon Nov 30 21:12:20 2015

开始读 , 读者编号 Thread-3 ,现在时间是 Mon Nov 30 21:12:20 2015
开始读 , 读者编号 Thread-5 ,现在时间是 Mon Nov 30 21:12:20 2015
开始读 , 读者编号 Thread-7 ,现在时间是 Mon Nov 30 21:12:20 2015
开始读 , 读者编号 Thread-9 ,现在时间是 Mon Nov 30 21:12:20 2015
完成读 , 读者编号 Thread-1 , 现在时间是 Mon Nov 30 21:12:22 2015
完成读 , 读者编号 Thread-3 , 现在时间是 Mon Nov 30 21:12:22 2015
完成读 , 读者编号 Thread-5 , 现在时间是 Mon Nov 30 21:12:22 2015
完成读 , 读者编号 Thread-7 , 现在时间是 Mon Nov 30 21:12:22 2015

⑷ python 多进程 进程池子进程结束怎么获取

在利用Python进行系统管理的时候，特别是同时操作多个文件目录，或者远程控制多台主机，并行操作可以节约大量的时间。当被操作对象数目不大时，可以直接利用multiprocessing中的Process动态成生多个进程，10几个还好，但如果是上百个，上千个目标，手动的去限制进程数量却又太过繁琐，这时候进程池Pool发挥作用的时候就到了。
Pool可以提供指定数量的进程，供用户调用，当有新的请求提交到pool中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求；但如果池中的进程数已经达到规定最大值，那么该请求就会等待，直到池中有进程结束，才会创建新的进程来它。这里有一个简单的例子：

#!/usr/bin/env python

#coding=utf-8

"""

Author: Squall

Last modified: 2011-10-18 16:50

Filename: pool.py

Description: a simple sample for pool class

"""

from multiprocessing import Pool

from time import sleep

def f(x):

for i in range(10):

print '%s --- %s ' % (i, x)

sleep(1)

def main():

pool = Pool(processes=3) # set the processes max number 3

for i in range(11,20):

result = pool.apply_async(f, (i,))

pool.close()

pool.join()

if result.successful():

print 'successful'

if __name__ == "__main__":

main()
先创建容量为3的进程池，然后将f(i)依次传递给它，运行脚本后利用ps aux | grep pool.py查看进程情况，会发现最多只会有三个进程执行。pool.apply_async()用来向进程池提交目标请求，pool.join()是用来等待进程池中的worker进程执行完毕，防止主进程在worker进程结束前结束。但必pool.join()必须使用在pool.close()或者pool.terminate()之后。其中close()跟terminate()的区别在于close()会等待池中的worker进程执行结束再关闭pool,而terminate()则是直接关闭。result.successful()表示整个调用执行的状态，如果还有worker没有执行完，则会抛出AssertionError异常。
利用multiprocessing下的Pool可以很方便的同时自动处理几百或者上千个并行操作，脚本的复杂性也大大降低。

⑸ pycharm python文件:进程已结束，退出代码为1，怎么处理

这个问题是因为python解释器环境遇到一些不能处理异常而结束了，
由于你的Pycharm工具底层其实也是考python.exe进程来解释Python程序的，当python.exe出现异常后，你的程序就不能执行了。
只要重启Pycharm工具，该工具会自动恢复python.exe的。别担心

⑹ Python：进程(threading)

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

https://docs.python.org/3/library/threading.html?highlight=threading#thread-objects

直接传入

继承 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() 会顺序执行，失去线程意义

https://docs.python.org/3/library/threading.html?#lock-objects

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

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

https://docs.python.org/3/library/threading.html#condition-objects

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

acquire([timeout])/release(): 与lock rlock 相同
wait([timeout]): 调用这个方法将使线程进入等待池，并释放锁。调用方法前线程必须已获得锁定，否则将抛出异常。
notify(): 调用这个方法将从等待池挑选一个线程并通知，收到通知的线程将自动调用acquire()尝试获得锁定（进入锁定池）；其他线程仍然在等待池中。调用这个方法不会释放锁定。调用方法前线程必须已获得锁定，否则将抛出异常。
notifyAll(): 调用这个方法将通知等待池中所有的线程，这些线程都将进入锁定池尝试获得锁定。调用这个方法不会释放锁定。使用前线程必须已获得锁定，否则将抛出异常。

threading.Semaphore(value=1)

https://docs.python.org/3/library/threading.html#semaphore-objects

acquire(blocking=True, timeout=None)
资源数大于0，减一并返回，等于0时等待，blocking为False不阻塞进程
返回值是申请结果
release()
资源数加1

https://docs.python.org/3/library/threading.html#event-objects

事件内置了一个初始为False的标志

is_set() 返回内置标志的状态
set() 设为True
clear() 设为False
wait(timeout=None) 阻塞线程并等待，为真时返回。返回值只会在等待超时时为False，其他情况为True

https://docs.python.org/3/library/threading.html#timer-objects

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

第一个参数是时间间隔，单位是秒，整数或者浮点数，负数不会报错直接执行不等待
可以用cancel() 取消

https://docs.python.org/3/library/threading.html#barrier-objects

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

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

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

⑺ Python怎样强制结束一个进程

import psutil
for process in psutil.process_iter():
cmdline = process.cmdline()
if "myscript.py" in cmdline:
process.terminate()

⑻ python多进程如何在主进程结束后 子进程也跟着退出

办法很多。通常的办法是，子线程出异常后，主进程检查到它的状态不正常，然后自己主动将其余线程退出，最后自己再退出。这是稳妥的办法。

另外的办法是，某一个子线程专用于监控状态。它发现状态不对时，直接强制进程退出。办法1，发消息给主进程，让主进程退出。办法2：用kill, pskill等方法，直接按进程PID杀进程。

⑼ python里怎么终止程序的执行

quit() exit()

执行到此命令时，程序终止。

如果是程序陷入死循环，想强制结束，则按Ctrl + C。这个特别关键。

Python的设计哲学是“优雅”、“明确”、“简单”。因此，Perl语言中“总是有多种方法来做同一件事”的理念在Python开发者中通常是难以忍受的。Python开发者的哲学是“用一种方法，最好是只有一种方法来做一件事”。

在设计Python语言时，如果面临多种选择，Python开发者一般会拒绝花俏的语法，而选择明确的没有或者很少有歧义的语法。由于这种设计观念的差异，Python源代码通常被认为比Perl具备更好的可读性，并且能够支撑大规模的软件开发。这些准则被称为Python格言。在Python解释器内运行import this可以获得完整的列表。

扩展质料：

Python在执行时，首先会将.py文件中的源代码编译成Python的byte code（字节码），然后再由Python Virtual Machine（Python虚拟机）来执行这些编译好的byte code。这种机制的基本思想跟Java，.NET是一致的。

然而，Python Virtual Machine与Java或.NET的Virtual Machine不同的是，Python的Virtual Machine是一种更高级的Virtual Machine。这里的高级并不是通常意义上的高级，不是说Python的Virtual Machine比Java或.NET的功能更强大。

而是说和Java 或.NET相比，Python的Virtual Machine距离真实机器的距离更远。或者可以这么说，Python的Virtual Machine是一种抽象层次更高的Virtual Machine。

基于C的Python编译出的字节码文件，通常是.pyc格式。

除此之外，Python还可以以交互模式运行，比如主流操作系统Unix/Linux、Mac、Windows都可以直接在命令模式下直接运行Python交互环境。直接下达操作指令即可实现交互操作。

参考资料：Python-网络

⑽ python 多进程

基于官方文档：
https://docs.python.org/zh-cn/3/library/multiprocessing.html
日乐购，刚才看到的一个博客，写的都不太对，还是基于官方的比较稳妥
我就是喜欢抄官方的，哈哈

通常我们使用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() 获得）

报错：

参考 ： https://blog.csdn.net/xiemanR/article/details/71700531

把 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 挂了:
参考： https://blog.csdn.net/hedongho/article/details/79139606
主要你要，对函数内部捕获错误，而不能让异常抛出就可以了。

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

报错：

参考：
https://blog.csdn.net/qq_15969343/article/details/84672527
普通的 process 当让可以穿多个参数，map 却不知道咋传的。
apply_async 和map 一样，不知道咋传的。

最简单的方法：
使用 starmap 而不是 map

结果：
子进程结束
1.8399453163146973
成功拿到结果了

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

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

关于 上面源码里面有 itertools.starmap
itertools 用法参考：
https://docs.python.org/zh-cn/3/library/itertools.html#itertool-functions

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

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

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

解决：
Manager().Queue() 代替 Queue()

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