Python进程-实现

fork介绍

Unix/Linux操作系统提供了一个fork()系统调用，它非常特殊。普通的函数调用，调用一次，返回一次，但是fork()调用一次，返回两次，因为操作系统自动把当前进程（称为父进程）复制了一份（称为子进程），然后，分别在父进程和子进程内返回。

子进程永远返回0，而父进程返回子进程的ID。这样做的理由是，一个父进程可以fork出很多子进程，所以，父进程要记下每个子进程的ID，而子进程只需要调用getppid()就可以拿到父进程的ID。

Python的os模块封装了常见的系统调用

import os

if __name__ == '__main__':

    print('进程 (%s) start...' % os.getpid())
    pid = os.fork()
    # time.sleep(10)
    if pid == 0:  # 子进程fork()返回0
        print("子进程{}，父进程{}".format(os.getpid(), os.getppid()))
    else:  # 父进程fork返回子进程的id
        print("父进程{},子进程{}".format(os.getpid(), pid))

--》》结果
进程 (3130) start...
父进程3130,子进程3131
子进程3131，父进程3130

multiprocessing模块介绍

python中的多线程无法利用CPU资源，在python中大部分计算密集型任务使用多进程。如果想要充分地使用多核CPU的资源（os.cpu_count()查看）

python中提供了非常好的多进程包multiprocessing。

multiprocessing模块用来开启子进程，并在子进程中执行功能（函数），该模块与多线程模块threading的编程接口类似。

multiprocessing的功能众多：支持子进程、通信和共享数据、执行不同形式的同步，提供了Process、Queue、Pipe、Lock等组件。

 计算密集型任务：如金融分析，科学计算

注意

记住，进程的执行是有操作系统调度的，python执行进程(start)只是向操作系统发信号，告诉操作系统，我要开辟一个进程，由操作系统调度执行。

同理，python终止进程(terminate)只是向操作系统发信号，告诉操作系统，我要终止一个进程，而不会马上终止，由操作系统调度终止进程。

Process类的介绍

1.创建进程的类

Process([group [, target [, name [, args [, kwargs]]]]])，由该类实例化得到的对象，表示一个子进程中的任务（尚未启动）

强调：
1. 需要使用关键字的方式来指定参数
2. args指定的为传给target函数的位置参数，是一个元组形式，必须有逗号

2.参数介绍

group参数未使用，值始终为None

target表示调用对象，即子进程要执行的任务

args表示调用对象的位置参数元组，args=(1,2,'al',)

kwargs表示调用对象的字典,kwargs={'name':'al','age':18}

name为子进程的名称

3.方法介绍

p.start()：启动进程，并调用该子进程中的p.run()
p.run():进程启动时运行的方法，正是它去调用target指定的函数，我们自定义类的类中一定要实现该方法  

p.terminate():强制终止进程p，不会进行任何清理操作，如果p创建了子进程，该子进程就成了僵尸进程，使用该方法需要特别小心这种情况。
如果p还保存了一个锁那么也将不会被释放，进而导致死锁
p.is_alive():如果p仍然运行，返回True

p.join([timeout]):主线程等待p终止（强调：是主线程处于等的状态，而p是处于运行的状态）。timeout是可选的超时时间，
需要强调的是，p.join只能join住start开启的进程，而不能join住run开启的进程

4.属性介绍

p.daemon：默认值为False，如果设为True，代表p为后台运行的守护进程，当p的父进程终止时，p也随之终止，并且设定为True后，p不能创建自己的新进程，必须在p.start()之前设置

p.name:进程的名称

p.pid：进程的pid

p.exitcode:进程在运行时为None、如果为–N，表示被信号N结束(了解即可)

p.authkey:进程的身份验证键,默认是由os.urandom()随机生成的32字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性，
这类连接只有在具有相同的身份验证键时才能成功（了解即可）

Process类的使用

注意：在windows中Process()必须放到# if __name__ == '__main__':下

开一个进程和主进程是并发的关系，我start一下就是先告诉操作系统我要开一个进程
，然而它不会等待，他会去执行下面的代码，完了他把进程开始后，就开始执行了

# window创造进程相当于导入，会无线递归创建
# Linux 是把父进程拷贝到子进程
import multiprocessing
import time
import threading

print('main process start1')
def func():
    print('subprocess start',time.asctime(time.localtime(time.time())))
    time.sleep(3)
    print('subprocess end',time.asctime(time.localtime(time.time())))

print('main process start2')
p = multiprocessing.Process(target=func, name='1号')
p.start()
print('main process end', time.asctime(time.localtime(time.time())),multiprocessing.current_process())
if __name__ == '__main__':
    pass
    # 默认所有进程结束后，程序才结束

"""
linux
main process start1
main process start2
main process end Fri Mar 23 00:20:29 2018 <_MainProcess(MainProcess, started)>
subprocess start Fri Mar 23 00:20:29 2018
subprocess end Fri Mar 23 00:20:32 2018

"""

"""
windows
Make sure that the main module can be safely
imported by a new Python interpreter without causing unintended
side effects (such a starting a new process)."

main process start1
main process start2
main process end Fri Mar 23 00:23:50 2018 <_MainProcess(MainProcess, started)>
main process start1 #相当于导入一次该程序，在main函数之前调用进程，会造成无限循环输出导致报错
subprocess start Fri Mar 23 00:23:50 2018
subprocess end Fri Mar 23 00:23:53 2018

"""

strat():方法的功能

　　1.开启进程
　　2.执行功能

开启进程方法一

import time
import multiprocessing
# import threading

def func():
    i = 0
    for _ in range(10000000):
        i += 1
    return  True

def main():
    start = time.time()
    p = multiprocessing.Process(target=func)  # 创建一个子进程
    p1 = multiprocessing.Process(target=func)
    p.start()
    p1.start()
    # p = threading.Thread(target=func)
    # p.start()
    func()
    end = time.time()
    print(end - start)

if __name__ == '__main__':
    main()

开启进程方法二

from multiprocessing import Process
import time
import random
import os
class pro(Process):
    def __init__(self,name):
        super().__init__() # 必须继承父类的一些属性
        self.name = name
    def run(self):  # 必须得实现一个run方法
        print('%s is work,父进程%s,当前进程%s'%(self.name,os.getppid(),os.getpid()))
        time.sleep(1)
        print('%s is work end'%self.name)
if __name__ =='__main__':
    p1 = pro('al')
    p2 = pro('b1')
    p3 = pro('c1')
    p1.start()
    p2.start()
    p3.start()
    print('主进程',os.getpid())

-》》输出
主进程 9116
b1 is work,父进程9116,当前进程4316
al is work,父进程9116,当前进程6664
c1 is work,父进程9116,当前进程10132
b1 is work end
al is work end
c1 is work end

使用daemon

1. 守护进程会在主进程代码执行结束后就终止

from multiprocessing import Process
import time
import random
import os
class My_Process(Process):
    def __init__(self,name):
        super().__init__() # 必须继承父类的一些属性
        self.name = name

    def run(self):  # 必须得实现一个run方法
        time.sleep(5)
        print('%s is work end'%self.name)

if __name__ =='__main__':
    start_time = time.time()
    print("process start")
    for i in range(5):
        t = My_Process('Process%s' % i)
        # t.daemon = True
        t.start()
    time.sleep(3)
    print("process end")
    print(time.time() - start_time)

"""
 t.daemon = False
process start
process end  #主进程运行完毕后，程序等待子进程运行完成后结束
0.020070791244506836
Process0 is work end
Process2 is work end
Process3 is work end
Process4 is work end
Process1 is work end

Process finished with exit code 0
"""

"""
 t.daemon = True
process start
process end   #主进程运行完毕后，守护进程结束
3.014104127883911

Process finished with exit code 0
"""

2. 守护进程内无法再开启子进程,否则抛出异常：AssertionError: daemonic processes are not allowed to have children

from multiprocessing import Process
import time
import random

def task(name):
    print('%s is start' %name)
    time.sleep(random.randrange(1,3))
    print('%s is end' %name)
    p = Process(target=time.sleep, args=(3,)) #在守护进程里面开子进程报错
    p.start()

if __name__ == '__main__':
    p=Process(target=task,args=('egon',))
    p.daemon=True #一定要在p.start()前设置,设置p为守护进程,禁止p创建子进程,并且父进程代码执行结束,p即终止运行

    p.start()
    p.join()
    print('主') #只要终端打印出这一行内容，那么守护进程p也就跟着结束掉了
-----------

egon is start
egon is end
Process Process-1:
Traceback (most recent call last):
  File "C:\Program Files\Python36\lib\multiprocessing\process.py", line 249, in _bootstrap
    self.run()
  File "C:\Program Files\Python36\lib\multiprocessing\process.py", line 93, in run
    self._target(*self._args, **self._kwargs)
  File "C:\Users\jingjing\PycharmProjects\py3Project\路飞\第四模块课件\01网络编程进阶\01 多进程\05 守护进程.py", line 55, in task
    p.start()
  File "C:\Program Files\Python36\lib\multiprocessing\process.py", line 103, in start
    'daemonic processes are not allowed to have children'
AssertionError: daemonic processes are not allowed to have children
主

思考下列代码的执行结果有可能有哪些情况？为什么？

from multiprocessing import Process

import time
def foo():
    print(123)
    time.sleep(1)
    print("end123")

def bar():
    print(456)
    time.sleep(3)
    print("end456")

if __name__ == '__main__':
    p1=Process(target=foo)
    p2=Process(target=bar)

    p1.daemon=True
    p1.start()
    p2.start()
    print("main-------")

-----输出
main-------
456
end456
当输出main之后，守护进程就结束了

　　

使用terminate

import multiprocessing
import time
import threading

def func():
    print('subprocess start',time.asctime(time.localtime(time.time())))
    time.sleep(3)
    print('subprocess end',time.asctime(time.localtime(time.time())))

if __name__ == '__main__':
    p = multiprocessing.Process(target=func, name='1号')
    p.start()
    p.terminate() # 终止进程
    time.sleep(5)
    print(p.is_alive()) # 判断这个进程是否存在
    # 默认所有进程结束后，程序才结束
    print('main process end', time.asctime(time.localtime(time.time())), multiprocessing.current_process())

-》》》输出
"""
False  终止进程后is_alive()返回False，没有执行print('subprocess s……
main process end Fri Mar 23 17:22:57 2018 <_MainProcess(MainProcess, started)>
"""

使用join

import multiprocessing
import time
import threading

def func():
    print('subprocess start',time.asctime(time.localtime(time.time())))
    time.sleep(3)
    print('subprocess end',time.asctime(time.localtime(time.time())))

if __name__ == '__main__':
    p = multiprocessing.Process(target=func, name='1号')
    p.start()
    p.join() # 等待子进程完成后，结束主线程
    # 默认所有进程结束后，程序才结束
    print('main process end', time.asctime(time.localtime(time.time())), multiprocessing.current_process())

"""
不使用join
# 主线程调用子线程后直接结束，然后子线程再结束
main process end Fri Mar 23 17:34:01 2018 <_MainProcess(MainProcess, started)>
subprocess start Fri Mar 23 17:34:01 2018
subprocess end Fri Mar 23 17:34:04 2018
"""

"""
使用join
subprocess start Fri Mar 23 17:30:20 2018
subprocess end Fri Mar 23 17:30:23 2018
# 等待子进程完成后，结束主线程
main process end Fri Mar 23 17:30:23 2018 <_MainProcess(MainProcess, started)>
"""

join用法考题

类似于单进程

from multiprocessing import Process
import time

def task(n, t):
    time.sleep(t)
    print('-------->%s' %n)

if __name__ == '__main__':
    p1=Process(target=task,args=(1,5))
    p2=Process(target=task,args=(2,2))
    p3=Process(target=task,args=(3,1))
    start = time.time()
    p1.start()
    p1.join()
    p2.start()
    p2.join()
    p3.start()
    p3.join()

    print('-------->time', time.time() - start)

------------------输出-----相当于单进程，时间等于3个进程执行时间的相加
-------->1
-------->2
-------->3
-------->time 9.534545183181763

类似于多进程　

from multiprocessing import Process
import time

def task(n, t):
    time.sleep(t)
    print('-------->%s' %n)

if __name__ == '__main__':
    p1=Process(target=task,args=(1,5))
    p2=Process(target=task,args=(2,2))
    p3=Process(target=task,args=(3,1))
    start = time.time()
    p_l = [p1,p2,p3]
    for p in p_l:
        p.start()

    for p in p_l:
        p.join()

    print('--------4 >time', time.time() - start)

---------------输出------------相当于多进程，执行时间等于最长进程的执行时间
-------->3
-------->2
-------->1
--------4 >time 5.624321699142456

　　

使用多进程实现并发的服务器

服务器端

import socket
import multiprocessing
server = socket.socket()
server.bind(('127.0.0.1', 9988))
server.listen(5)

def read_msg(conn, addr):
    while True:
        try:
            data = conn.recv(1024)
            if data:  # 正常接收数据
                print('收到{}:数据{}'.format(addr,data.decode()))
                conn.send(data)
            else:  # 收到空消息，关闭
                print('close:{}'.format(addr))
                break
        except Exception as e:
            print(e)
            break
    conn.close()

if __name__ == '__main__':
    while True:
        print('-------主进程,等待连接------')
        conn, addr = server.accept()
        print('创建一个新的进程，和客户端{}通信'.format(addr))
        client= multiprocessing.Process(target=read_msg, args=(conn, addr))
        # client = threading.Thread(target=readable, args=((conn, addr)))
        # p.start()
        client.start()
    server.close()

客户端

# 客户端
import socket  # 导入socket模块

socket_client = socket.socket() # 创建监听套接字
socket_client.connect(('127.0.0.1', 9988))  # 连接套接字 ,要连接的IP与端口

while 1:
       cmd = input("Please input cmd:")   # 与人交互，输入命令
       if not cmd: continue
       elif cmd == 'q':break
       socket_client.send(cmd.encode('utf-8'))     # 把命令发送给服务端
       data = socket_client.recv(1024)
       print('recv',data)

socket_client.close()

练习题

from multiprocessing import Process

n=100 #在windows系统中应该把全局变量定义在if __name__ == '__main__'之上就可以了

def work():
    global n
    n=0
    print('子进程内: ',n)

if __name__ == '__main__':
    p=Process(target=work)
    p.start()
    print('主进程内: ',n)

进程之间的内存空间是共享的还是隔离的？上述代码的执行结果是什么？
进程之间的内存空间是隔离的
执行结果：
主进程内:  100
子进程内:  0

改写下列程序，分别别实现下述打印效果

from multiprocessing import Process
import time
import random

def task(n):
    time.sleep(random.randint(1,3))
    print('-------->%s' %n)

if __name__ == '__main__':
    p1=Process(target=task,args=(1,))
    p2=Process(target=task,args=(2,))
    p3=Process(target=task,args=(3,))

    p1.start()
    p2.start()
    p3.start()

    print('-------->4')

效果一：保证最先输出-------->4

from multiprocessing import Process
import time
import random

def task(n):
    time.sleep(random.randint(1,3))
    print('-------->%s' %n)

if __name__ == '__main__':
    p1=Process(target=task,args=(1,))
    p2=Process(target=task,args=(2,))
    p3=Process(target=task,args=(3,))

    p1.start()
    p2.start()
    p3.start()

    print('-------->4')

----------输出
-------->4
-------->1
-------->3
-------->2

　　

效果二：保证最后输出-------->4

from multiprocessing import Process
import time
import random

def task(n):
    time.sleep(random.randint(1,3))
    print('-------->%s' %n)

if __name__ == '__main__':
    p1=Process(target=task,args=(1,))
    p2=Process(target=task,args=(2,))
    p3=Process(target=task,args=(3,))

    p1.start()
    p2.start()
    p3.start()

    p1.join()
    p2.join()
    p3.join()
    print('-------->4')
----------------------------输出
-------->1
-------->3
-------->2
-------->4

　　

效果三：保证按顺序输出

from multiprocessing import Process
import time
import random

def task(n):
    time.sleep(random.randint(1,3))
    print('-------->%s' %n)

if __name__ == '__main__':
    p1=Process(target=task,args=(1,))
    p2=Process(target=task,args=(2,))
    p3=Process(target=task,args=(3,))

    p1.start()
    p1.join()
    p2.start()
    p2.join()
    p3.start()
    p3.join()

    print('-------->4')

-------------------------输出
-------->1
-------->2
-------->3
-------->4

2、判断上述三种效果，哪种属于并发，哪种属于串行？

第一种和第二种属于并发，最后一种属于并行