进程&进程池

进程

服务器中, s.listen(n) n不能无限大,以为内存不可能无限大,n表示内存同一时间接纳的等待连接数,可以看成一个(队列),取出一个拿去建立连接,然后再放进一个,队列中一直保持n个连接

请求.

补充一点:
　　print() 是计算操作, 计算机中除了IO,都是计算(PS:cpu干的活都是计算).

进程的运行回收机制: 主进程等子进程运行完 才回收子进程,自己再关闭

父进程杀死了,子进程就会变成孤儿进程(甚至变成僵尸进程)

非常重要的一个概念:
　　运行py文件,在进程中显示的不是xx.py, 而是解释器的python.exe,
　　是因为代码只是一堆符号,没有意义,只有把代码传给python解释器,python解释器解释后,调用的python解释器的功能.
　　实际上用的python解释器的功能,所以进程中显示运行的是python.exe解释器而不是xx.py文件.
　　(举个例子:py文件中一行代码为print,那么python解释器就会调用自己的打印功能)

查看进程号：

import os
print(os.getpid())    #打印进程id号
print(os.getppid())     # 父进程id号

查看进程和杀死进程:

cmd解释器中:
tasklist |findstr python  #管道符 过滤 查看python关键字 进程
干掉python进程
tskill python

tskill 进程name
tskill 进程pid号

运行环境的父进程:

运行一个xxx.py (python3环境下) , 打印这个进程的父进程id号,发现是pycharm 的id号.为什么呢?
    pycharm 运行 python3 xxx.py , 然后 产生一个 python.exe 进程.所以pycharm是这个python.exe的父进程
    (pycharm 运行 python3 xxx.py     ====>>   python.exe)

PS:如果在cmd中运行,这个python.exe的父进程就是cmd的id号

jion():

jion(),主进程等待子进程

import time
from multiprocessing import Process


def task(name):
    time.sleep(2)
    print('%s' % name)


if __name__ == '__main__':
    p = Process(target=task,args=('kitty',))
    p.start()
    p.join()                    #等 子进程运行完毕,主进程才继续往下运行
    print('主进程')

如果有多个子进程:p1 p2 p3

p1.start()
p1.join()
p2.start()
p2.join()
p3.start()
p3.join()
# 这种情况下,相当于串行(等待上一个进程执行完,才继续往下执行下一个进程)

-

p1.start()
p2.start()
p3.start()
p1.join()
p2.join()
p3.join()
# 这种情况下,是并发(PS:join()的顺序先后没关系)

可以简洁点：

p_l = [p1,p2,p3]
for p in p_l:
    p.start()
for p in p_l:
    p.join()

name = None

进程名可以自定义:

if __name__ == '__main__':
    p = Process(target=task,args=('kitty',),name='haha')
    p.start()
    p.join()
    print(p.name)           #haha  自定义子进程名字
    print('主进程')

terminate(): 杀死进程

is_alive(): 判断进程是否活着

def task(name):
    time.sleep(2)
    print('%s' % name)


if __name__ == '__main__':
    p = Process(target=task,args=('kitty',))
    p.start()
    p.terminate()               #杀死进程p
    print(p.is_alive())         #True  之所以是True,而不是False,是因为杀死进程p.terminate()只是发了一个信号,主进程马上就判断
                                        # (杀死进程需  要时间)
    print('主进程')

注意:
　　慎用, 如果儿子进程开了个孙子进程,就会产生孤儿进程(比较危险)
　　现实场景也很少这种操作

进程池

1.进程池中存放的就是进程,只不过加上了数目的限制,

2.进程池造出来后,不会开新的进程,从始至终就是造进程池时定义的数目

3.等进程池中的所有进程都完毕,先关门,在等(shutdown(wait = True))

示例：

import time
from concurrent.futures import ProcessPoolExecutor


def task(name):
    time.sleep(2)
    print('%s' % name)


if __name__ == '__main__':
    p = ProcessPoolExecutor(4)          # 立刻造好4个进程
    # p.submit(task,'kitty1')
    # p.submit(task,'kitty2')
    # p.submit(task,'kitty3')
    # p.submit(task,'kitty4')
    for i in range(1, 11):
        p.submit(task, 'kitty%s' % i)       #submit() 往里面丢任务
    print('主进程')

提交/调用 任务的方式

1.同步调用:

　　提交/调用一个任务,然后就在原地等着,等到该任务执行完毕拿到结果,再执行下一行代码

2.异步调用:

　　提交/调用一个任务,不在原地等着,直接执行下一行代码.

from concurrent.futures import ProcessPoolExecutor

新版本中(新模块中)根本就没有同步接口,只有异步接口,就是submit()

新版本中:

　　关门+等

　　shutdown(wait = True)

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

from multiprocessing import Process, Pool

老版本中(Pool)中有个同步接口 p.apply()

老版本中:

　　关门+等

　　pool.close()

　　pool.join()
--------------------------------------------------------

同步调用方式:

　　开进程 等待 再开,再等这种提交任务的方式,想当于串行

for p in p_l:
    p.start()
    p.join()

示例：

import time
from concurrent.futures import ProcessPoolExecutor


def task(name, n):
    time.sleep(1)
    print('%s' % name)
    return n**2


if __name__ == '__main__':
    p = ProcessPoolExecutor(4)
    p_l = []
    for i in range(1, 11):
        obj = p.submit(task, 'kitty%s' % i, i)
        print(obj.result())                 #相当于start和join连用
    print('主进程')

# kitty1
# 1
# kitty2
# 4
# kitty3
# 9
# kitty4
# 16
# kitty5
# 25
# kitty6
# 36
# kitty7
# 49
# kitty8
# 64
# kitty9
# 81
# kitty10
# 100
# 主进程

异步调用方式:

for i in range(10):
    p.submit(func,'xx')

示例：

import time
from concurrent.futures import ProcessPoolExecutor


def task(name, n):
    time.sleep(1)
    print('%s' % name)
    return n**2


if __name__ == '__main__':
    p = ProcessPoolExecutor(4)
    p_l = []
    for i in range(1, 11):
        obj = p.submit(task, 'kitty%s' % i, i)      # obj是个对象,通过对象拿到结果
        p_l.append(obj)
    p.shutdown(wait = True)            #shutdown(wait = True) 等,但是前提是进程池中不能再放进新的任务了,否则数目不准确(先关门+等)
    print('主进程')
    for i in p_l:
        print(i.result())

# kitty1
# kitty2
# kitty3
# kitty4
# kitty5
# kitty6
# kitty7
# kitty8
# kitty9
# kitty10
# 主进程
# 1
# 4
# 9
# 16
# 25
# 36
# 49
# 64
# 81
# 100