Python（12）进程与线程（一）

#下面的代码只有在unix或者linux中才能正常运行，这里使用centos，mac的内核也是unix的一种，所以也可以执行
[root@centos-1 ~]# cat test.py
#!/usr/bin/env python3
#-*- coding: utf-8 -*-
import os
print("父进程ID为：%s" % os.getpid())
pid = os.fork()
if pid == 0:
        print('子进程ID为：%s,父进程ID为：%s' %(os.getpid(),os.getppid()))
else:
        print('父进程ID %s 创建了子进程ID %s' %(os.getpid(),pid))
#执行：
[root@centos-1 ~]# python test.py
父进程ID为：973
父进程ID 973 创建了子进程ID 974
子进程ID为：974,父进程ID为：973
#解析：
1、要看懂输出，就需要先认真看一下上面的概述，'使用fork()函数后，调用一次，返回两次，并且分别在父进程和子进程内返回'，仔细读过这句话之后，我们可以知道，在'pid = os.fork()'之后，分成了两个进程分别执行之后的代码
2、从代码输出的第二行可以看出，代码先执行的是pid不等于0的语句，同样从上面的概述中可以知道，'子进程永远返回为0，父进程返回子进程的id'，只有子进程才会返回0，所以，这里很明显是先执行的父进程，那么pid的值就等于子进程的id，也就是974，而os.getpid()可以得到当前进程的id也就是973，所以最终的输出为：'父进程ID 973 创建了子进程ID 974'
3、通过上面的解析后，最后一行输出就很好理解了，父进程执行完成、返回之后，开始执行子进程，因为子进程永远返回为0，所以pid为0，然后执行if判断为True的语句，os.getpid()得到当前进程id，也就是974，os.getppid()得到当前进程的父进程id，也就得到了973，最终输出：'子进程ID为：974,父进程ID为：973'

#作用：
process模块是一个创建进程的模块，借助这个模块，就可以完成进程的创建
#使用：
Process([group [, target [, name [, args [, kwargs]]]]])，由该类实例化得到的对象，表示一个子进程中的任务（尚未启动）
#参数：
group：进程所属组，基本上不用，参数没有使用则值始终为None
target：表示调用对象，即子进程将要执行的任务
args：表示调用对象的位置参数元组，例如 args=(1,2,'test',)
kwargs：表示调用对象的字典，例如 kwargs={'name':'zhangsan','age':22}
name：设置子进程的名称
#注意事项：
1、每个参数需要使用关键字方式来指定，例如 name='test'这样的，指定参数为指定的值
2、args指定的是给target参数传入的位置参数，是一个元组，要记得在末尾加上逗号
#方法：
在创建实例p后
p.start()：启动进程，并调用该子进程中的p.run()
p.run()：进程启动时运行的方法，正是它去调用target指定的函数，我们自定义类的类中一定要实现该方法
p.join([timeout])：主线程等待实例p终止'（要注意主线程处于等待状态，但是p的子进程是处于运行状态的）'，timeout是可选参数，指定超时时间，需要注意的是，p.join()只能终止p.start()开启的进程，而不能终止p.run开启的进程，通常用于进程之间的同步
p.terminate()：用来杀死子进程的
p.is_alive()：判断子进程是否存活，返回True为存活，False为已经关闭

#编写脚本，脚本在windows、linux、unix都能执行
#-*- coding: utf-8 -*-
from multiprocessing import Process
import os 
def run_proc(name):
    print("运行子进程，名称:%s,ID:%s" %(name,os.getpid()))
if __name__ == "__main__":
    print("父进程ID:%s" % os.getpid())
    p = Process(target=run_proc,args=('test',))
    print('子进程开始执行')
    p.start()
    p.join()
    print('子进程执行结束')
#执行输出
父进程ID:15460
子进程开始执行
运行子进程，名称:test,ID:15204
子进程执行结束
#解析
1、看过process的使用方法之后，这里就比较好理解了，p是创建的子进程实例，这个子进程会执行run_proc函数，并且传入参数'test'
2、p.start()开始执行p子进程，也就是执行run_proc函数，然后p.join()终止子进程，最后输出print

pool = multiprocessing.Pool(processes = 3)  #最多允许3个进程

#-*- coding: utf-8 -*-
from multiprocessing import Pool
import os,time,random
def time_test(name):
    print('运行进程名称 %s,ID %s' %(name,os.getpid()))
    start = time.time()
    time.sleep(random.random() * 3)
    end = time.time()
    print('执行进程 %s ID %s 所使用的时间是 %0.2f 秒' %(name,os.getpid(),(end - start)))
if __name__ == '__main__':
    print('主进程ID %s'% os.getpid())
    p = Pool(processes=4)  #这里指定进程最多4个
    for i in range(5):
        p.apply_async(time_test,args=('test',))
    print('等待所有进程执行完毕')
    p.close()
    p.join()
    print('所有进程执行完毕') 
#执行返回结果：
主进程ID 10708
等待所有进程执行完毕
运行进程名称 test,ID 12620
运行进程名称 test,ID 14176
运行进程名称 test,ID 16088
运行进程名称 test,ID 7744
执行进程 test ID 7744 所使用的时间是 0.64 秒
运行进程名称 test,ID 7744
执行进程 test ID 16088 所使用的时间是 0.91 秒
执行进程 test ID 12620 所使用的时间是 1.85 秒
执行进程 test ID 14176 所使用的时间是 2.17 秒
执行进程 test ID 7744 所使用的时间是 2.94 秒
所有进程执行完毕
#解析：
在看过process后，这里也比较好理解，但是可以看到输出信息中，在第四次运行time_test函数后，有一个进程先返回了，然后才执行第五次，这是因为当pool线程池数量满了之后，新进来的请求需要等待前面有进程处理完之后，再处理新的请求，因为设置了进程最多4个，而for循环的调用是5次，所以第5次请求就需要等待有进程执行完毕后才会执行新请求
'可以发现，执行第五次的进程id，是复用了一开始创建的进程'

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

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

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

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

1、'args'： 要执行的shell命令，默认应该是一个字符串序列，如['df', '-Th']或('df', '-Th')，也可以是一个字符串，如'df -Th'，但是想要直接使用linux命令的话，需要把shell参数的值设置为True
2、'shell'： 如果shell为True，那么指定的命令将通过shell执行。如果我们需要访问某些shell的特性，如管道符、文件名通配符、环境变量扩展功能，这将是非常有用的。当然，python本身也提供了许多类似shell的特性的实现，如glob、fnmatch、os.walk()、os.path.expandvars()、os.expanduser()和shutil等
3、'check'： 如果check参数的值是True，且执行命令的进程以非0状态码退出，则会抛出一个CalledProcessError的异常，且该异常对象会包含 参数、退出状态码、以及stdout和stderr(如果它们有被捕获的话)
4、'stdout, stderr：input'：`该参数是传递给Popen.communicate()`，通常该参数的值必须是一个字节序列，如果universal_newlines=True，则其值应该是一个字符串
----------------------------------------------------------------------
- run()函数默认不会捕获命令执行结果的正常输出和错误输出，如果我们向获取这些内容需要传递subprocess.PIPE，然后可以通过返回的CompletedProcess类实例的stdout和stderr属性或捕获相应的内容
- call()和check_call()函数返回的是命令执行的状态码，而不是CompletedProcess类实例，所以对于它们而言stdout和stderr不适合赋值为subprocess.PIPE
- check_output()函数默认就会返回命令执行结果，所以不用设置stdout的值，如果我们希望在结果中捕获错误信息，可以执行stderr=subprocess.STDOUT
- `subprocess.PIPE表示为进程创建新的管道，subprocess.DEVNULL表示使用os.devnull（代表当前系统的回收站）`
----------------------------------------------------------------------
5、'universal_newlines'： 该参数影响的是输入与输出的数据格式，比如它的值默认为False，此时stdout和stderr的输出是字节序列；当该参数的值设置为True时，stdout和stderr的输出是字符串

class subprocess.Popen(args, bufsize=-1, executable=None, stdin=None, stdout=None, stderr=None, 
    preexec_fn=None, close_fds=True, shell=False, cwd=None, env=None, universal_newlines=False,
    startup_info=None, creationflags=0, restore_signals=True, start_new_session=False, pass_fds=())

1、'args'： 要执行的shell命令，可以是字符串，也可以是命令各个参数组成的序列。当该参数的值是一个字符串时，该命令的解释过程是与平台相关的，因此通常建议将args参数作为一个序列传递
2、'bufsize'： 指定缓存策略，0表示不缓冲，1表示行缓冲，其他大于1的数字表示缓冲区大小，负数 表示使用系统默认缓冲策略。
3、'stdin, stdout, stderr'： 分别表示程序标准输入、输出、错误句柄
4、'preexec_fn'： 用于指定一个将在子进程运行之前被调用的可执行对象，只在Unix平台下有效
5、'close_fds'： 如果该参数的值为True，则除了0,1和2之外的所有文件描述符都将会在子进程执行之前被关闭
6、'shell'： 该参数用于标识是否使用shell作为要执行的程序，如果shell值为True，则建议将args参数作为一个字符串传递而不要作为一个序列传递
7、'cwd'： 如果该参数值不是None，则该函数将会在执行这个子进程之前改变当前工作目录
8、'env'： 用于指定子进程的环境变量，如果env=None，那么子进程的环境变量将从父进程中继承。如果env!=None，它的值必须是一个映射对象
9、'universal_newlines'： 如果该参数值为True，则该文件对象的stdin，stdout和stderr将会作为文本流被打开，否则他们将会被作为二进制流被打开
10、'startupinfo和creationflags'： 这两个参数只在Windows下有效，它们将被传递给底层的CreateProcess()函数，用于设置子进程的一些属性，如主窗口的外观，进程优先级等

1、'Popen.poll()'：用于检查子进程（命令）是否已经执行结束，没结束返回None，结束后返回状态码
2、'Popen.wait(timeout=None)'：等待子进程结束，并返回状态码；如果在timeout指定的秒数之后进程还没有结束，将会抛出一个TimeoutExpired异常
3、'Popen.communicate(input=None, timeout=None)'：该方法可用来与进程进行交互，比如发送数据到stdin，从stdout和stderr读取数据，直到到达文件末尾
-------------------------------------------------------------------------------------
#Popen.communicate()方法注释：
- 该方法中的可选参数 input 应该是将被发送给子进程的数据，或者如没有数据发送给子进程，该参数应该是None。input参数的数据类型必须是字节串，如果universal_newlines参数值为True，则input参数的数据类型必须是字符串
- 该方法返回一个元组(stdout_data, stderr_data)，这些数据将会是字节串或字符串，如果universal_newlines的值为True
- 如果在timeout指定的秒数后该进程还没有结束，将会抛出一个TimeoutExpired异常。捕获这个异常，然后重新尝试通信不会丢失任何输出的数据。但是超时之后子进程并没有被杀死，为了合理的清除相应的内容，一个好的应用应该手动杀死这个子进程来结束通信
- 需要注意的是，这里读取的数据是缓冲在内存中的，所以，如果数据大小非常大或者是无限的，就不应该使用这个方法
-----------------------------------------------------------------------------------------
4、'Popen.send_signal(signal)'：发送指定的信号给这个子进程
5、'Popen.terminate()'：停止该子进程
6、'Popen.kill()'：杀死该子进程

#-*- coding: utf-8 -*-
import subprocess
print('$ nslookup www.baidu.com')
r = subprocess.call(['nslookup','www.baidu.com'])  #执行指定命令，返回状态
print(r)
#输出：
$ nslookup www.baidu.com
服务器:  UnKnown
Address:  10.10.11.41
非权威应答:
名称:    www.a.shifen.com
Addresses:  110.242.68.3
          110.242.68.4
Aliases:  www.baidu.com
0

#-*- coding: utf-8 -*-
import subprocess
print('$ nslookup')
p = subprocess.Popen(['nslookup'], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
output, err = p.communicate(b'www.baidu.com\nexit')    #使用\n换行符，可以执行多条命令
print(output.decode('unicode_escape'))  #指定字符集，原文中是utf-8，但是windows报错了，所以改成unicode
print('Exit code:', p.returncode)
#输出：
$ nslookup
ĬÈÏ·þÎñÆ÷:  UnKnown  #因为是unicode所以是乱码
Address:  10.10.11.41
> ·þÎñÆ÷:  UnKnown
Address:  10.10.11.41
Ãû³Æ:    www.a.shifen.com
Addresses:  110.242.68.4
          110.242.68.3
Aliases:  www.baidu.com
> exit
Exit code: 0
#解析：
上面的代码相当于执行了'nslookup'，然后手动输入'www.baidu.com'、'exit'