036.进程及多进程的使用

一、进程理论知识（二）

（一）进程的创建

windows：CreateProcess

Linux：fork

（二）进程的终止

1.正常退出

2.被其他进程杀死（win：task /F /PID 进程编号）

（三）程序运行的三种状态

1.运行态；

2.就绪态；

3.阻塞态。

（四）程序优化的核心法则

1.降低IO操作（硬盘IO、网络IO）

2.减少网络IO：内存IO==》本地硬盘IO==》网络IO

（五）进程的三种状态于调用任务的两种方式

1.进程的三种状态

（1）非阻塞态之运行态；

​ 即程序正在运行。

（2）非阻塞态之就绪态；

​ 即程序在准备运行，如下图所示。

（3）阻塞态。

​ 阻塞调用是指调用结果返回之前，当前线程会被挂起（如遇到IO操作）。函数只有在得到结果之后才会将阻塞的线程激活。

​ 阻塞调用和同步调用实际上是不同的，对于同步调用来说，很多时候当前线程还是激活的，只是从逻辑上当前函数没有返回而已。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OjzeikZa-1597930298077)(D:\Onedrive\文档\01学习资料\全栈15博客笔记\python学习博客及作业\day036.进程及多进程的使用\001 进程的三种状态.png)]

2.调用任务的两种方式

（1）同步调用

​ 所谓同步，就是在发出一个功能调用时，在没有得到结果之前，该调用就不会返回。

​ 按照这个定义，大多数函数都是同步调用。但是一般而言，我们在说同步，异步的时候，特指那些需要其他部件协作或者需要一定时间完成的任务。

（2）异步调用

​ 异步概念和同步相对。当一个异步功能调用发出后，调用者不能立刻得知结果。当该异步功能完成后，通过状态、通知或回调来通知调用者。

​ 如果异步功能用状态来通知，那么调用者就需要每隔一定的时间检查一次，效率就很低。如果使用通知的方式，效率则很高。因为异步功能几乎不需要做额外的操作。至于回调函数，其实和通知没太多区别。

3.小结

（1）同步与异步针对的是函数/任务的调用方式：

​ 同步就是当一个进程发起一个函数（任务）调用的时候，一直等到函数（任务）完成，而进程继续处于激活状态。

​ 而异步情况下是当一个进程发起一个函数（任务）调用的时候，不会等函数返回，而是继续往下执行，当函数返回的时候通过状态、通知、事件等方式通知进程任务的完成。

（2）阻塞于非阻塞针对的是进程或线程：

​ 阻塞是当请求不能满足的时候就将进程挂起，而非阻塞则不会阻塞当前进程。

二、python并发之multiprocessing模块

（一）什么是multiprocessing模块

​ multiprocessing模块用来开启子进程，并在子进程中执行我们定制的任务（比如函数）。

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

​ **注意：**与线程不同，进程没有任何共享状态，进程修改的数据，改动仅限于该进程内。

（二）Process类介绍

1.创建进程的类：

Process([group [, target [, name [, args [, kwargs]]]]])
# 由该类实例化得到的对象，表示一个子进程中的任务（尚未启动）
# 注意：
1) 需要使用关键字的方式来指定参数；
2) args指定的为传给target函数的位置参数，是一个元组形式，必须有逗号。

2.参数介绍：

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

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

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

4) kwargs 表示调用对象的字典， kwargs = {'name':'lxx', 'age':'18'}

5) name 为子进程的名称。

3.方法介绍：

1) p.start(): 启动进程，并调用该子进程中的p.run();

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

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

4) p.is_alive(): 如果p仍然运行，返回True。

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

4.属性介绍：

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

2) p.name: 进程的名称。

3) p.pid: 进程的pid。

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

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

（三）Process类的使用

注意：在Windows系统中，Process() 必须到 ： if __ name __ == ‘__ main __’ : 下

1.创建并开启子进程的两种方式：

​ 由于子进程的创建需要调动系统的资源，所以子进程启动时间上有延迟，示例代码展示了这种延迟：

①：方式一：使用函数的方式

# 创建子进程的方式一：
import time
import random
from multiprocessing import Process


def task(name):
    print('%s is running' % name)
    time.sleep(random.randrange(1, 5))
    print('%s is ending' % name)

if __name__ == '__main__':  # 必须加这一行，不然win下运行会报错
    
    p1 = Process(target=task, args=('子进程1',))  # 元组，必须加逗号！
    p2 = Process(target=task, args=('子进程2',))  
    p3 = Process(target=task, args=('子进程3',))  
    p4 = Process(target=task, args=('子进程4',))  


    p1.start()
    p2.start()
    p3.start()
    p4.start()
    print('______主进程————————————————————>>>>>')
    
"""
______主进程————————————————————>>>>>
子进程1 is running
子进程2 is running
子进程3 is running
子进程4 is running
子进程3 is ending
子进程2 is ending子进程4 is ending

子进程1 is ending
"""

②：方式二：使用类的方式

# 创建子进程的方式二：
import time
import random
from multiprocessing import Process


class task(Process):
    def __init__(self, name):
        super().__init__()
        self.name = name

    def run(self):
        print('%s is running' % self.name)
        time.sleep(random.randrange(1, 5))
        print('%s is ending' % self.name)


if __name__ == '__main__':
    p1 = task('子进程1')
    p2 = task('子进程2')
    p3 = task('子进程3')
    p4 = task('子进程4')

    p1.start()  # start会自动调用run
    p2.start()
    p3.start()
    p4.start()
    print('______主进程————————————————————>>>>>')
    
"""
______主进程————————————————————>>>>>
子进程1 is running
子进程4 is running
子进程3 is running
子进程2 is running
子进程1 is ending
子进程3 is ending子进程2 is ending

子进程4 is ending
"""

2.进程之间的内存空间是隔离的：

​ 子进程和主进程之间的内存空间是隔离的。

# 进程之间的内存空间是隔离的
from multiprocessing import Process

n = 100


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


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

3.Process对象的join方法：

​ **作用：**主进程，等待子进程结束。

​ **注意：**join()方法不是让多个程序变成串行，是让主进程等待某个子进程一段时间后再运行，卡住的是主进程，其余的子进程仍然是并发的执行，让主进程等待多久，取决于join()时间最长的一个。

# Process对象的join方法: 让主进程等待
import time
import random
from multiprocessing import Process


class task(Process):
    def __init__(self, name):
        super().__init__()
        self.name = name

    def run(self):
        print('%s is running' % self.name)
        time.sleep(random.randrange(1, 5))
        print('%s is ending' % self.name)


if __name__ == '__main__':
    p1 = task('子进程1')
    p2 = task('子进程2')
    p3 = task('子进程3')
    p4 = task('子进程4')

    print(time.time(),'——————> 001')
    p1.start()  # start会自动调用run
    print(time.time(),'——————> 002')
    p1.join(1.5)  # 自p1启动那一刻起，让主进程等待1.5s再执行
    print(time.time(),'——————> 003')
    p2.start()
    p3.start()
    p4.start()

    print(time.time(),'——————> 004')
    print('______主进程————————————————————>>>>>')
    print(time.time(),'——————> 005')
    
"""
1597927218.6315486 ——————> 001
1597927218.652153 ——————> 002
子进程1 is running
1597927220.1582189 ——————> 003
1597927220.179413 ——————> 004
______主进程————————————————————>>>>>
1597927220.179413 ——————> 005
子进程2 is running
子进程3 is running
子进程4 is running
子进程4 is ending
子进程1 is ending
子进程2 is ending
子进程3 is ending
"""

​

#上述启动进程与join进程可以简写为
p_l=[p1,p2,p3,p4]

for p in p_l:
    p.start()

for p in p_l:
    p.join()

4.Process对象的其他方法：

①：terminate, is_alive方法

# Process对象的其他方法: terminate, is_alive
import time
import random
from multiprocessing import Process


class task(Process):
    def __init__(self, name):
        super().__init__()
        self.name = name

    def run(self):
        print('%s is running' % self.name)
        time.sleep(random.randrange(1, 5))
        print('%s is ending' % self.name)


if __name__ == '__main__':
    p1 = task('子进程1')
    p2 = task('子进程2')
    p3 = task('子进程3')
    p4 = task('子进程4')

    p1.start()  # start会自动调用run
    p1.join(1.5)  # 自p1启动那一刻起，让主进程等待1.5s再执行
    p1.terminate()  # 关闭进程,不会立即关闭,所以is_alive立刻查看的结果可能还是存活
    print(p1.is_alive())  # True
    p2.start()

②：子进程名字的设置

# Process对象的其他方法: 子进程名字的设置
import time
import random
from multiprocessing import Process


class task(Process):
    def __init__(self, name):
        # super().__init__()
        # self.name = name

        self.name = name
        super().__init__()  # Process的__init__方法会执行self.name=task-1,根据子进程的个数依次编号
        #                    #所以加到这里,会覆盖我们的self.name=name

    def run(self):
        print('%s is running' % self.name)
        time.sleep(random.randrange(1, 5))
        print('%s is ending' % self.name)


if __name__ == '__main__':
    p1 = task('子进程1')
    p2 = task('子进程2')
    p3 = task('子进程3')

    p1.start()  # start会自动调用run
    p2.start()
    p3.start()
    print('______主进程————————————————————>>>>>')
   
"""
______主进程————————————————————>>>>>
task-2 is running
task-1 is running
task-3 is running
task-1 is ending
task-2 is ending
task-3 is ending
"""
       time.sleep(random.randrange(1, 5))
        print('%s is ending' % self.name)


if __name__ == '__main__':
    p1 = task('子进程1')
    p2 = task('子进程2')
    p3 = task('子进程3')

    p1.start()  # start会自动调用run
    p2.start()
    p3.start()
    print('______主进程————————————————————>>>>>')
   
"""
______主进程————————————————————>>>>>
task-2 is running
task-1 is running
task-3 is running
task-1 is ending
task-2 is ending
task-3 is ending
"""