python进程

进程                                                                                                                     

进程是计算机中的程序关于某数据集合上的一次运行活动,是系统进行资源费配和调度的基本单位,是操作系统结构的基础。在当代面向线程设计的计算机结构中，进程是线程的容器，同一个进程中的多个线程可以共享其资源，而进程与进城之间可以起到数据隔离的作用（即同一个程序执行两次，就会在操作系统出现两个进程，所以同时运行同一个软件做不同的事情也不会混乱）。

进程的并行和并发                                                                                                                       

并行：是指两者同时进行，微观上，就是在一个时刻，有不同的程序执行，要求必须有多个处理器。

并发：是指系统资源有限，两者只能交替轮流使用资源，目的是为了提高效率，从宏观上看某个时刻是同时进行的。

同步、异步、阻塞、非阻塞                                                                                                     

 同步和异步：       

　　同步就是一个任务的完成需要依赖另一个任务时，只有等待被依赖的任务完成后，依赖的任务才算完成，这是一种可靠的任务序列。成功都成功，失败都失败，两个任务的 状态保持一致。

        异步（回调机制）是不需要等待被依赖的任务完成，只是通知被依赖的任务要完成什么操作，依赖的任务也立即执行，自己完成了整个任务就算完成了。至于被依赖的任务是否完成，依赖他的任务无法确定，所以这是一种不可靠的任务序列。

阻塞和非阻塞：

　　阻塞：就是等待。

　　非阻塞：不等待。　　

　　比如创建socket对某个地址进行connect、获取接收数据recv时默认都会等待（连接成功或接收到数据），才执行后续操作。
　　如果设置setblocking(False),以上两个过程就不再等待，但是会报BlockingIOError的错误，只要捕获即可。

  使用process模块创建进程            

 在Windows操作系统中由于没有fork(linux操作系统中创建进程的机制)，在创建子进程的时候会自动 import 启动它的这个文件， 而在 import 的时候又执行了整个文件。
 因此如果将process()直接写在文件中就会无限递归创建子进程报错。 所以必须把创建子进程的部分使用if __name__ ==‘__main__’ 判断保护起来，import 的时候 ，就不会递归运行了。 

import time
from multiprocessing import Process

def f(n):    
    print(n)
    print('子进程')

if __name__ == '__main__':
    p = Process(target=f, args=(666,))
    p.start()
    time.sleep(1)
    print('主进程')

import time
from multiprocessing import Process

def f(name):
    print('hello', name)
    time.sleep(1)
    print('子进程')
if __name__ == '__main__':
    p = Process(target=f, args=('bob',))
    p.start()
    p.join()
    print('父进程')

继承创建进程:

def task(n):
    n+=1
    print(n)
if __name__ == '__main__':
    for i in range(3):
        p=Process(target=task,args=(i,))
        p.start()

进程之间的数据隔离:

class MyProcess(Process):
    def __init__(self,name):
        super().__init__()
        self.name=name
    def run(self):
        print(os.getpid())
        print(self.name)
if __name__ == '__main__':

    p1=MyProcess('messi')
    p2=MyProcess('c罗')
    p3=MyProcess('salah')

    p1.start() #start会自动调用run
    p2.start()
    p3.start()

    p1.join()
    print(os.getppid())

进程之间的数据共享:

　　Queue:

import multiprocessing

def task(arg,q):
    q.put(arg)
if __name__ == '__main__':
    q = multiprocessing.Queue()
    for i in range(5):
        p=multiprocessing.Process(target=task,args=(i,q))
        p.start()
    while True:
        v=q.get()
        print(v)

　　Manager:

import multiprocessing
import time

def task(arg,dic):
    time.sleep(2)
    dic[arg]=100
if __name__ == '__main__':
    m=multiprocessing.Manager()
    dic=m.dict()
    process_list=[]
    for i in range(5):
        p=multiprocessing.Process(target=task,args=(i,dic))
        p.start()
        process_list.append(p)
    while 1:
        count=0
        for p in process_list:
            if not p.is_alive():
                count+=1
        if count == len(process_list):
            break
    print(dic)

进程池:

import time
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor

def task(arg):
    time.sleep(2)
    print(arg)

if __name__ == '__main__':
    pool = ProcessPoolExecutor(5)
    for i in range(10):
        pool.submit(task,i)