python中的线程和进程

进程与线程的历史

我们都知道计算机是由硬件和软件组成的。硬件中的CPU是计算机的核心，它承担计算机的所有任务。 操作系统是运行在硬件之上的软件，是计算机的管理者，它负责资源的管理和分配、任务的调度。 程序是运行在系统上的具有某种功能的软件，比如说浏览器，音乐播放器等。 每次执行程序的时候，都会完成一定的功能，比如说浏览器帮我们打开网页，为了保证其独立性，就需要一个专门的管理和控制执行程序的数据结构——进程控制块。 进程就是一个程序在一个数据集上的一次动态执行过程。 进程一般由程序、数据集、进程控制块三部分组成。我们编写的程序用来描述进程要完成哪些功能以及如何完成；数据集则是程序在执行过程中所需要使用的资源；进程控制块用来记录进程的外部特征，描述进程的执行变化过程，系统可以利用它来控制和管理进程，它是系统感知进程存在的唯一标志。

在早期的操作系统里，计算机只有一个核心，进程执行程序的最小单位，任务调度采用时间片轮转的抢占式方式进行进程调度。每个进程都有各自的一块独立的内存，保证进程彼此间的内存地址空间的隔离。 随着计算机技术的发展，进程出现了很多弊端，一是进程的创建、撤销和切换的开销比较大，二是由于对称多处理机（对称多处理机（SymmetricalMulti-Processing）又叫SMP，是指在一个计算机上汇集了一组处理器(多CPU)，各CPU之间共享内存子系统以及总线结构）的出现，可以满足多个运行单位，而多进程并行开销过大。 这个时候就引入了线程的概念。 线程也叫轻量级进程，它是一个基本的CPU执行单元，也是程序执行过程中的最小单元，由线程ID、程序计数器、寄存器集合 和堆栈共同组成。线程的引入减小了程序并发执行时的开销，提高了操作系统的并发性能。 线程没有自己的系统资源，只拥有在运行时必不可少的资源。但线程可以与同属与同一进程的其他线程共享进程所拥有的其他资源。

 

进程与线程之间的关系

线程是属于进程的，线程运行在进程空间内，同一进程所产生的线程共享同一内存空间，当进程退出时该进程所产生的线程都会被强制退出并清除。线程可与属于同一进程的其它线程共享进程所拥有的全部资源，但是其本身基本上不拥有系统资源，只拥有一点在运行中必不可少的信息(如程序计数器、一组寄存器和栈)。

 

threading模块

threading 模块建立在 _thread 模块之上。thread 模块以低级、原始的方式来处理和控制线程，而 threading 模块通过对 thread 进行二次封装，提供了更方便的 api 来处理线程。

import threading
import time
 
def worker(num):
    """
    thread worker function
    :return:
    """
    time.sleep(1)
    print("Thread %d" % num)
    return
 
for i in range(20):
    t = threading.Thread(target=worker,args=(i,)，name=“t.%d” % i)
    t.start()

thread方法说明

t.start() : 激活线程，

t.getName() : 获取线程的名称

t.setName() ： 设置线程的名称 

t.name : 获取或设置线程的名称

t.is_alive() ： 判断线程是否为激活状态

t.isAlive() ：判断线程是否为激活状态

t.setDaemon() 设置为后台线程或前台线程（默认：False）;通过一个布尔值设置线程是否为守护线程，必须在执行start()方法之后才可以使用。如果是后台线程，主线程执行过程中，后台线程也在进行，主线程执行完毕后，后台线程不论成功与否，均停止；如果是前台线程，主线程执行过程中，前台线程也在进行，主线程执行完毕后，等待前台线程也执行完成后，程序停止

t.isDaemon() ： 判断是否为守护线程

t.ident ：获取线程的标识符。线程标识符是一个非零整数，只有在调用了start()方法之后该属性才有效，否则它只返回None。

t.join() ：逐个执行每个线程，执行完毕后继续往下执行，该方法使得多线程变得无意义

t.run() ：线程被cpu调度后自动执行线程对象的run方法

线程锁threading.RLock和threading.Lock

我们使用线程对数据进行操作的时候，如果多个线程同时修改某个数据，可能会出现不可预料的结果，为了保证数据的准确性，引入了锁的概念。

例：假设列表A的所有元素就为0，当一个线程从前向后打印列表的所有元素，另外一个线程则从后向前修改列表的元素为1,那么输出的时候，列表的元素就会一部分为0，一部分为1,这就导致了数据的不一致。锁的出现解决了这个问题。

import threading
import time
 
globals_num = 0
 
lock = threading.RLock()
 
def Func():
    lock.acquire()  # 获得锁 
    global globals_num
    globals_num += 1
    time.sleep(1)
    print(globals_num)
    lock.release()  # 释放锁 
 
for i in range(10):
    t = threading.Thread(target=Func)
    t.start()

threading.RLock和threading.Lock 的区别

RLock允许在同一线程中被多次acquire。而Lock却不允许这种情况。 如果使用RLock，那么acquire和release必须成对出现，即调用了n次acquire，必须调用n次的release才能真正释放所占用的琐。

import threading
lock = threading.Lock()    #Lock对象
lock.acquire()
lock.acquire()  #产生了死琐。
lock.release()
lock.release()
import threading
rLock = threading.RLock()  #RLock对象
rLock.acquire()
rLock.acquire()    #在同一线程内，程序不会堵塞。
rLock.release()
rLock.release()

threading.Event

Event是线程间通信最间的机制之一：一个线程发送一个event信号，其他的线程则等待这个信号。用于主线程控制其他线程的执行。 Events 管理一个flag，这个flag可以使用set()设置成True或者使用clear()重置为False，wait()则用于阻塞，在flag为True之前。flag默认为False。

  • Event.wait([timeout]) ： 堵塞线程，直到Event对象内部标识位被设为True或超时（如果提供了参数timeout）。
  • Event.set() ：将标识位设为Ture
  • Event.clear() ： 将标识伴设为False。
  • Event.isSet() ：判断标识位是否为Ture。
 1 import threading
 2  
 3 def do(event):
 4     print('start')
 5     event.wait()
 6     print('execute')
 7  
 8 event_obj = threading.Event()
 9 for i in range(10):
10     t = threading.Thread(target=do, args=(event_obj,))
11     t.start()
12  
13 event_obj.clear()
14 inp = input('input:')
15 if inp == 'true':
16     event_obj.set()
View Code

当线程执行的时候，如果flag为False，则线程会阻塞，当flag为True的时候，线程不会阻塞。它提供了本地和远程的并发性。

threading.Condition:

一个condition变量总是与某些类型的锁相联系，这个可以使用默认的情况或创建一个，当几个condition变量必须共享和同一个锁的时候，是很有用的。锁是conditon对象的一部分：没有必要分别跟踪。

condition变量服从上下文管理协议：with语句块封闭之前可以获取与锁的联系。 acquire() 和 release() 会调用与锁相关联的相应的方法。

其他和锁关联的方法必须被调用，wait()方法会释放锁，当另外一个线程使用 notify() or notify_all()唤醒它之前会一直阻塞。一旦被唤醒，wait()会重新获得锁并返回，

Condition(lock=None)

Condition类实现了一个conditon变量。 这个conditiaon变量允许一个或多个线程等待，直到他们被另一个线程通知。 如果lock参数，被给定一个非空的值，，那么他必须是一个lock或者Rlock对象，它用来做底层锁。否则，会创建一个新的Rlock对象，用来做底层锁。

  • wait(timeout=None) ： 等待通知，或者等到设定的超时时间。当调用这wait()方法时，如果调用它的线程没有得到锁，那么会抛出一个RuntimeError 异常。 wati()释放锁以后，在被调用相同条件的另一个进程用notify() or notify_all() 叫醒之前 会一直阻塞。wait() 还可以指定一个超时时间。

如果有等待的线程，notify()方法会唤醒一个在等待conditon变量的线程。notify_all() 则会唤醒所有在等待conditon变量的线程。

注意： notify()和notify_all()不会释放锁，也就是说，线程被唤醒后不会立刻返回他们的wait() 调用。除非线程调用notify()和notify_all()之后放弃了锁的所有权。

 

在典型的设计风格里，利用condition变量用锁去通许访问一些共享状态，线程在获取到它想得到的状态前，会反复调用wait()。修改状态的线程在他们状态改变时调用 notify() or notify_all()，用这种方式，线程会尽可能的获取到想要的一个等待者状态。 例子： 生产者-消费者模型，

 1 import threading
 2 import time
 3 def consumer(cond):
 4     with cond:
 5         print("consumer before wait")
 6         cond.wait()
 7         print("consumer after wait")
 8  
 9 def producer(cond):
10     with cond:
11         print("producer before notifyAll")
12         cond.notifyAll()
13         print("producer after notifyAll")
14  
15 condition = threading.Condition()
16 c1 = threading.Thread(name="c1", target=consumer, args=(condition,))
17 c2 = threading.Thread(name="c2", target=consumer, args=(condition,))
18  
19 p = threading.Thread(name="p", target=producer, args=(condition,))
20  
21 c1.start()
22 time.sleep(2)
23 c2.start()
24 time.sleep(2)
25 p.start()
View Code

consumer()线程要等待producer()设置了Condition之后才能继续。

queue模块

Queue 就是对队列，它是线程安全的

举例来说，我们去肯德基吃饭。厨房是给我们做饭的地方，前台负责把厨房做好的饭卖给顾客，顾客则去前台领取做好的饭。这里的前台就相当于我们的队列。

这个模型也叫生产者-消费者模型。

 1 import queue
 2 
 3 q = queue.Queue(maxsize=0)  # 构造一个先进显出队列，maxsize指定队列长度，为0 时，表示队列长度无限制。
 4 
 5 q.join()    # 等到队列为kong的时候，在执行别的操作
 6 q.qsize()   # 返回队列的大小 （不可靠）
 7 q.empty()   # 当队列为空的时候，返回True 否则返回False （不可靠）
 8 q.full()    # 当队列满的时候，返回True，否则返回False （不可靠）
 9 q.put(item, block=True, timeout=None) #  将item放入Queue尾部，item必须存在，可以参数block默认为True,表示当队列满时，会等待队列给出可用位置，
10 　　　　　　　　　　　　　　　　　　　　　　　　 为False时为非阻塞，此时如果队列已满，会引发queue.Full 异常。 可选参数timeout，表示 会阻塞设置的时间，过后，
11 　　　　　　　　　　　　　　　　　　　　　　　　  如果队列无法给出放入item的位置，则引发 queue.Full 异常
12 q.get(block=True, timeout=None) #   移除并返回队列头部的一个值，可选参数block默认为True，表示获取值的时候，如果队列为空，则阻塞，为False时，不阻塞，
13 　　　　　　　　　　　　　　　　　　　　　　若此时队列为空，则引发 queue.Empty异常。 可选参数timeout，表示会阻塞设置的时候，过后，如果队列为空，则引发Empty异常。
14 q.put_nowait(item) #   等效于 put(item,block=False)
15 q.get_nowait() #    等效于 get(item,block=False)
View Code

生产者--消费者：

 1 #!/usr/bin/env python
 2 import Queue
 3 import threading
 4 
 5 
 6 message = Queue.Queue(10)
 7 
 8 
 9 def producer(i):
10     while True:
11         message.put(i)
12 
13 
14 def consumer(i):
15     while True:
16         msg = message.get()
17 
18 
19 for i in range(12):
20     t = threading.Thread(target=producer, args=(i,))
21     t.start()
22 
23 for i in range(10):
24     t = threading.Thread(target=consumer, args=(i,))
25     t.start()
View Code

multiprocessing模块

multiprocessing是python的多进程管理包，和threading.Thread类似。直接从侧面用subprocesses替换线程使用GIL的方式，由于这一点，multiprocessing模块可以让程序员在给定的机器上充分的利用CPU。

在multiprocessing中，通过创建Process对象生成进程，然后调用它的start()方法，

1 from multiprocessing import Process
2  
3 def f(name):
4     print('hello', name)
5  
6 if __name__ == '__main__':
7     p = Process(target=f, args=('bob',))
8     p.start()
9     p.join()
View Code

进程间的数据共享

在使用并发设计的时候最好尽可能的避免共享数据，尤其是在使用多进程的时候。 如果你真有需要 要共享数据， multiprocessing提供了两种方式。

Shared memory

数据可以用Value或Array存储在一个共享内存地图里，如下：

 1 from multiprocessing import Process, Value, Array
 2  
 3 def f(n, a):
 4     n.value = 3.1415927
 5     for i in range(len(a)):
 6         a[i] = -a[i]
 7  
 8 if __name__ == '__main__':
 9     num = Value('d', 0.0)
10     arr = Array('i', range(10))
11  
12     p = Process(target=f, args=(num, arr))
13     p.start()
14     p.join()
15  
16     print(num.value)
17     print(arr[:])
View Code

输出：

3.1415927
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]

创建num和arr时，“d”和“i”参数由Array模块使用的typecodes创建：“d”表示一个双精度的浮点数，“i”表示一个有符号的整数，这些共享对象将被线程安全的处理。

Array(‘i’, range(10))中的‘i’参数：

1 ‘c’: ctypes.c_char　　　　 ‘u’: ctypes.c_wchar　　　　‘b’: ctypes.c_byte　　　　 ‘B’: ctypes.c_ubyte
2 ‘h’: ctypes.c_short　　　  ‘H’: ctypes.c_ushort　　  ‘i’: ctypes.c_int　　　　　 ‘I’: ctypes.c_uint
3 ‘l’: ctypes.c_long,　　　　‘L’: ctypes.c_ulong　　　　‘f’: ctypes.c_float　　　　‘d’: ctypes.c_double
View Code

Server process

由Manager()返回的manager提供list, dict, Namespace, Lock, RLock, Semaphore, BoundedSemaphore, Condition, Event, Barrier, Queue, Value and Array类型的支持。

 1 from multiprocessing import Process, Manager
 2  
 3 def f(d, l):
 4     d[1] = '1'
 5     d['2'] = 2
 6     d[0.25] = None
 7     l.reverse()
 8  
 9 if __name__ == '__main__':
10     with Manager() as manager:
11         d = manager.dict()
12         l = manager.list(range(10))
13  
14         p = Process(target=f, args=(d, l))
15         p.start()
16         p.join()
17  
18         print(d)
19         print(l)
View Code

输出：

{0.25: None, 1: '1', '2': 2}
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

Server process manager比 shared memory 更灵活，因为它可以支持任意的对象类型。另外，一个单独的manager可以通过进程在网络上不同的计算机之间共享，不过他比shared memory要慢。

使用工作池（Using a pool of workers）

Pool类描述了一个工作进程池，他有几种不同的方法让任务卸载工作进程。

进程池内部维护一个进程序列，当使用时，则去进程池中获取一个进程，如果进程池序列中没有可供使用的进进程，那么程序就会等待，直到进程池中有可用进程为止。

我们可以用Pool类创建一个进程池， 展开提交的任务给进程池。 例：

 1 from multiprocessing import Pool
 2 import time
 3 def myFun(i):
 4     time.sleep(2)
 5     return i+100
 6 
 7 def end_call(arg):
 8     print("end_call",arg)
 9 
10 p = Pool(5)
11 
12 # print(p.map(myFun,range(10)))
13 
14 for i in range(10):
15     p.apply_async(func=myFun,args=(i,),callback=end_call)
16 
17 print("end")
18 p.close()
19 p.join()
View Code
 1 from multiprocessing import Pool, TimeoutError
 2 import time
 3 import os
 4  
 5 def f(x):
 6     return x*x
 7  
 8 if __name__ == '__main__':
 9     # 创建4个进程 
10     with Pool(processes=4) as pool:
11  
12         # 打印 "[0, 1, 4,..., 81]" 
13         print(pool.map(f, range(10)))
14  
15         # 使用任意顺序输出相同的数字， 
16         for i in pool.imap_unordered(f, range(10)):
17             print(i)
18  
19         # 异步执行"f(20)" 
20         res = pool.apply_async(f, (20,))      # 只运行一个进程 
21         print(res.get(timeout=1))             # 输出 "400" 
22  
23         # 异步执行 "os.getpid()" 
24         res = pool.apply_async(os.getpid, ()) # 只运行一个进程 
25         print(res.get(timeout=1))             # 输出进程的 PID 
26  
27         # 运行多个异步执行可能会使用多个进程 
28         multiple_results = [pool.apply_async(os.getpid, ()) for i in range(4)]
29         print([res.get(timeout=1) for res in multiple_results])
30  
31         # 是一个进程睡10秒 
32         res = pool.apply_async(time.sleep, (10,))
33         try:
34             print(res.get(timeout=1))
35         except TimeoutError:
36             print("发现一个 multiprocessing.TimeoutError异常")
37  
38         print("目前，池中还有其他的工作")
39  
40     # 退出with块中已经停止的池 
41     print("Now the pool is closed and no longer available")
官方实例
class multiprocessing.pool.Pool([processes[, initializer[, initargs[, maxtasksperchild[, context]]]]])

一个进程池对象可以控制工作进程池的哪些工作可以被提交，它支持超时和回调的异步结果，有一个类似map的实现。

  • processes ：使用的工作进程的数量，如果processes是None那么使用 os.cpu_count()返回的数量。
  • initializer： 如果initializer是None，那么每一个工作进程在开始的时候会调用initializer(*initargs)。
  • maxtasksperchild：工作进程退出之前可以完成的任务数，完成后用一个心的工作进程来替代原进程，来让闲置的资源被释放。maxtasksperchild默认是None，意味着只要Pool存在工作进程就会一直存活。
  • context: 用在制定工作进程启动时的上下文，一般使用 multiprocessing.Pool() 或者一个context对象的Pool()方法来创建一个池，两种方法都适当的设置了context

注意：Pool对象的方法只可以被创建pool的进程所调用。

New in version 3.2: maxtasksperchild

New in version 3.4: context

 

进程池的方法

  • apply(func[, args[, kwds]]) ：使用arg和kwds参数调用func函数，结果返回前会一直阻塞，由于这个原因，apply_async()更适合并发执行，另外，func函数仅被pool中的一个进程运行。

  • apply_async(func[, args[, kwds[, callback[, error_callback]]]]) ： apply()方法的一个变体，会返回一个结果对象。如果callback被指定，那么callback可以接收一个参数然后被调用，当结果准备好回调时会调用callback，调用失败时，则用error_callback替换callback。 Callbacks应被立即完成，否则处理结果的线程会被阻塞。

  • close() ： 阻止更多的任务提交到pool，待任务完成后，工作进程会退出。

  • terminate() ： 不管任务是否完成，立即停止工作进程。在对pool对象进程垃圾回收的时候，会立即调用terminate()。

  • join() : wait工作线程的退出，在调用join()前，必须调用close() or terminate()。这样是因为被终止的进程需要被父进程调用wait（join等价与wait），否则进程会成为僵尸进程。

  • map(func, iterable[, chunksize])¶

  • map_async(func, iterable[, chunksize[, callback[, error_callback]]])¶

  • imap(func, iterable[, chunksize])¶

  • imap_unordered(func, iterable[, chunksize])

  • starmap(func, iterable[, chunksize])¶

  • starmap_async(func, iterable[, chunksize[, callback[, error_back]]])

 

 

协程

协程又叫微线程，从技术的角度来说，“协程就是你可以暂停执行的函数”。如果你把它理解成“就像生成器一样”，那么你就想对了。 线程和进程的操作是由程序触发系统接口，最后的执行者是系统；协程的操作则是程序员。

协程存在的意义：对于多线程应用，CPU通过切片的方式来切换线程间的执行，线程切换时需要耗时（保存状态，下次继续）。协程，则只使用一个线程，在一个线程中规定某个代码块执行顺序。

协程的适用场景：当程序中存在大量不需要CPU的操作时（IO），适用于协程；

Python3.5的 async/await 新特性

async/await 是对 3.3版本引入 yeild from 的扩展.

定义协程：

@types.coroutine   # 和 asyncio.coroutine 一样
def ping_server(ip):
    # ping code here...
async def ping_server(ip):
    # ping code here...

注意：使用 async def 定义的协程函数，不能包含任何形式的 yield 语句，只有return 和await 可以从协程中返回值。 await只能用于 async def 中，await 接受的对象必须是 awaitable 对象， awaitable 对象要么是一个协程；要么是一个定义了__await__()方法的对象，且__await__()必须返回一个不是协程的迭代器。

 

Event Loop

Event Loop是一种等待程序分配时间或消息的编程架构。简单的说就是 当事件A发生的时候，我们就去执行事件B。 最简单的例子就是：当我们浏览网页的时候，我们点击页面的某个元素，这个点击事件会被 JavaScript 捕捉到，然后 JavaScript 就会检查这个事件是否绑定了onclick()回调函数来处理这个事件，只要绑定了，onclick()回调函数就会被执行。

event loop是协程执行的控制点， 如果你希望执行协程， 就需要用到它们。

event loop提供了如下的特性：

  • 注册、执行、取消延时调用(异步函数)
  • 创建用于通信的client和server协议(工具)
  • 创建和别的程序通信的子进程和协议(工具)
  • 把函数调用送入线程池中

 

协程示例：

import asyncio
 
async def cor1():
    print("COR1 start")
    await cor2()
    print("COR1 end")
 
async def cor2():
    print("COR2")
 
loop = asyncio.get_event_loop()
loop.run_until_complete(cor1())
loop.close()

最后三行是重点。

  • asyncio.get_event_loop()  : asyncio启动默认的event loop 
  • run_until_complete()  :  这个函数是阻塞执行的，知道所有的异步函数执行完成，
  • close()  :  关闭event loop。

python 2.7 中的实现：

 1 from greenlet import greenlet
 2  
 3  
 4 def test1():
 5     print 12
 6     gr2.switch()
 7     print 34
 8     gr2.switch()
 9  
10  
11 def test2():
12     print 56
13     gr1.switch()
14     print 78
15  
16 gr1 = greenlet(test1)
17 gr2 = greenlet(test2)
18 gr1.switch()
greenlet
 1 import gevent
 2  
 3 def foo():
 4     print('Running in foo')
 5     gevent.sleep(0)
 6     print('Explicit context switch to foo again')
 7  
 8 def bar():
 9     print('Explicit context to bar')
10     gevent.sleep(0)
11     print('Implicit context switch back to bar')
12  
13 gevent.joinall([
14     gevent.spawn(foo),
15     gevent.spawn(bar),
16 ])
gevent
 1 from gevent import monkey; monkey.patch_all()
 2 import gevent
 3 import urllib2
 4 
 5 def f(url):
 6     print('GET: %s' % url)
 7     resp = urllib2.urlopen(url)
 8     data = resp.read()
 9     print('%d bytes received from %s.' % (len(data), url))
10 
11 gevent.joinall([
12         gevent.spawn(f, 'https://www.python.org/'),
13         gevent.spawn(f, 'https://www.yahoo.com/'),
14         gevent.spawn(f, 'https://github.com/'),
15 ])
gevent遇到io操作自动变换

subprocess模块

通过使用subprocess模块可以创建新的进程，连接到他们的输入/输出/错误管道，并获取他们的返回值。 该模块计划替代及一个旧的模块的方法：

os.system
os.spawn*

使用subprocess模块

在所有用例调用subprocess时推荐使用run()方法，更高级的用例，可以直接使用subprocess.Popen接口。

run()方法

在Python3.5增加的。

subprocess.run(args, *, stdin=None, input=None, stdout=None, stderr=None, shell=False, timeout=None, check=False)

run()默认不会捕捉到标准输出和标准错误输出，要捕捉的话，可以为标准输出和标准错误输出指定subprocess.PIPE(一个特殊值，可被用于Popen的stdin, stdout或 stderr参数，表示一个标准流的管道应该被打开， Popen.communicate()用的最多)。

  • args ：args应该是一个字符串或者一个序列。
  • timeout：设置超时时间，会传递给subprocess.Popen.communicate()。如果超时，子进程会被杀死并等待。子进程被终止后会报告一个 TimeoutExpired异常。
  • input参数会传递给subprocess.Popen.communicate()，从而作为subprocess的标准输入。当我们使用的时候，内部的Popen对象会自动创建stdin=PIPE，stdin参数可能不会被使用。
  • check：如果check参数为True，且进程退出的时候得到退出码一个非0的值，会报告一个 CalledProcessError异常
  • shell:shell参数默认为False，此时arg参数应该是一个列表。subprocess.run(["ls","-l"]) ; 当shell=True时，args可以是一个字符串。subprocess.run("ls -l",shell=True)。
 1 >>> ret = subprocess.run(["ls", "-l"])  # doesn't capture output 
 2 CompletedProcess(args=['ls', '-l'], returncode=0)
 3 >>> print(ret.stdout)
 4 None
 5  
 6 >>> subprocess.run("exit 1", shell=True, check=True)
 7 Traceback (most recent call last):
 8   ...
 9 subprocess.CalledProcessError: Command 'exit 1' returned non-zero exit status 1
10  
11 >>> ret1 = subprocess.run(["ls", "-l", "/dev/null"], stdout=subprocess.PIPE)
12 CompletedProcess(args=['ls', '-l', '/dev/null'], returncode=0,
13 stdout=b'crw-rw-rw- 1 root root 1, 3 Jan 23 16:23 /dev/null\n')
14  
15 >>> print(ret.stdout)
16 b'crw-rw-rw- 1 root root 1, 3 6\xe6\x9c\x88   8 06:50 /dev/null\n'
View Code

call方法

subprocess.call(args, *, stdin=None, stdout=None, stderr=None, shell=False, timeout=None)¶

call()方法等价于：run(..., check=True)和run()方法类所以，只是不支持input参数和check参数; 

注意： 不要在这个方法里使用stdout=PIPE 或 stderr=PIPE，当到一个管道的输出填满系统的管道缓存时，子进程会被阻塞。

 

check_call方法

subprocess.check_output(args, *, stdin=None, stderr=None, shell=False, universal_newlines=False, timeout=None)

check_call()方法等价于： run(..., check=True, stdout=PIPE).stdout

3.1新增，3.3时增加了timeout参数，3.4时增加了对关键字参数的支持

check_output()方法

内部调用的是run()方法，但是会捕捉到stdout

>>> ret = subprocess.check_output(["ls", "-l", "/dev/null"])
>>> print(ret)
b'crw-rw-rw- 1 root root 1, 3 6\xe6\x9c\x88   8 06:50 /dev/null\n'

Popen类

上面的四个方法本质上调用的都是subprocess中的Popen类。

Popen对象都有以下方法：

poll() ： 检查子进程是否已经终止，返回一个returncode，相当于exit code。

wait() ： 等待子进程终止，返回一个returncode

communicate(input=None) ：和进程进行交互：发送数据到stdin；从stdout和stderr读取数据，直到读取完。等待进程终止。可选参数input会传递数据给子进程，当input=None事，没有数据传递给子进程。 communicate() 返回一个元组 (stdout, stderr). 注意： 读取的数据在内存的buffer中，所以当数据大小大于buffer或者没有限制时，不要使用这个方法。



posted @ 2016-07-02 15:32  龙哥1995xyabc  阅读(232)  评论(0)  编辑  收藏  举报