进程

什么是进程：

　　进程就是正在执行的一段程序代码。

进程与程序的关系：

　　程序只是一堆的代码，而进程是操作系统为这一堆代码执行所创建的内存空间。

进程需要使用的模块：

from multiprocessing    import  Process

该模块下需要掌握的方法：

　　start()方法--------------->开启进程

from  multiprocessing  import   Process
import   time
def  test(name):
    print('%s is running'%name)
    time.sleep(3)

if __name__ == '__main__':#在windows系统下，开子进程的代码必须写到这一行下面
    p = Process(target=test,args=('liuyinzhou',))#创建进程
    p.start()#开启进程。给操作系统发送一个信号，让操作系统开进程（申请内存+拷贝父进程的地址空间,但该进程执行的时间由操作系统决定
    print('done')

　　join（）方法----------->等待进程的完成

from  multiprocessing  import  Process
import os
import  time
def   task():
    print('run',os.getpid())
    time.sleep(3)
    print('done',os.getpid())
if __name__ == '__main__':
    p1 = Process(target=task,)
    p1.start()#父进程等待子进程的完成，直到子进程运行完之后才会执行下面的代码。
    print('主',os.getpid())

使用进程实现并发

from  socket import  *
import  threading

def xiancheng(ip,port):
        server = socket(AF_INET, SOCK_STREAM)
        server.bind((ip,port))
        server.listen(5)
        while True:
            client, add = server.accept()
            print(add)
            p = threading.Thread(target=commu, args=(client,))
            p.start()
        server.close()

def commu(client):
        while True:
            try:
                data_bytes= client.recv(1024)
                if not data_bytes:break
                client.send(data_bytes.upper())
            except Exception:
                break
        client.close()

if __name__ == '__main__':
    xiancheng('127.0.0.1',8878)

from  socket import  *
client = socket(AF_INET,SOCK_STREAM)
ip_port = ('127.0.0.1',8878)
client.connect(ip_port)
while  True:
    msg = input('>>>:')
    if not msg :continue
    client.send(msg.encode('utf-8'))
    server_data = client.recv(1024)
    print(server_data.decode('utf-8'))
client.close()

存在的问题：

　　目前确实实现了并发，但是如果有一万个客户端请求，那么就会在服务端创建一万个进程，此时服务端的服务器已经死掉了，因此不行无限制的在客户端开多个进程实现并发。解决的办法是：进程池。

进程池：

'''
提交或调用任务的方式：
    1.同步调用，提交或调用一个任务时，然后在原地等待，等待该任务执行完毕以及拿到结果后，再执行下一个任务
    2.异步调用：提交或调用一个任务时，不在原地等待，直接执行下面的任务，等所有任务都执行完之后，再调用每次任务的结果
'''
from concurrent.futures import ProcessPoolExecutor
import  time,random,os

def piao(name,i):
    print('%s is piaoing %s'%(name,os.getpid()))
    time.sleep(random.randint(1,4))
    return i**2
if __name__ == '__main__':

    objs = []
    p = ProcessPoolExecutor(5)#创建进程池对象，并指定进程池大小，向操作系统发送创建五个进程信号，等待提交任务
    # for i  in range(10):#使用for循环把任务提交给进程池，但每次只能执行5个进程，操作的对象是进程池（五个进程），不是五个单个的进程
    #     res = p.submit(piao,'alex %s'%i,i).result() ---------------> 同步调用
    #     print(res)


    for i  in range(10):#使用for循环把任务提交给进程池，但每次只能执行5个进程，操作的对象是进程池（五个进程），不是五个单个的进程
        obj = p.submit(piao,'alex %s'%i,i) # ---------------> 异步调用
        objs.append(obj)#------------>每次只是获取进程对象。

    for obj  in  objs:#只要是某个进程运行完毕，得到结果后就会打印。
        print(obj.result()) #由于采用异步的调用方式，因此在遍历列表的过程当中有可能某些进程还没有执行完成。

    p.shutdown(wait=True,)#阻止外来任务的提交，等待进程池中的任务都执行完毕，再运行之后的代码
    print('主进程',os.getpid())

存在的问题：

　　目前确实解决了之前大量进程对服务器的影响，但是创建进程需要的时间长，解决这一问题的办法就是：线程

注意：

　　不管是使用进程还是线程实现并发，线程与进程的运行时间都不可控，即不收人为控制，两者的运行时间由操作系统决定。