一.多任务运行控制

1 . 等待子任务结束（join）

进程或者线程添加 join 方法之后，会等待子任务结束，如果没有结束则会阻塞，直到子任务结束，因此join一般都是放在程序的最后面，通过阻塞进行等待。（进程与线程都可使用）

import time
import multiprocessing

def new_time():
    """
    返回asc格式的当前时间
    :return:
    """
    return time.asctime(time.localtime(time.time()))

def func(x,y):
    print('func-start', new_time())
    print(x+y)
    time.sleep(5)
    print('func-end', new_time())

if __name__ == '__main__':
    print('main-start',new_time())

    p1 = multiprocessing.Process(target = func,args=(1,2)) # 实例化一个新的子进程
    p1.start()

    time.sleep(5)

    p1.join()  # 等待子进程结束
    
print('main-end',new_time())

主进程的模拟耗时操作与子进程同时运行，但因子进程需要多运行一部 x + y ，以至于子进程结束时间要迟于主进程结束时间。

但因加入了 join 方法，主进程只会在子进程运行结束后才会结束。（ main 是主进程，func 是子进程）

2.获取当前进程

在进程内容获取当前进程，方便查找问题（进程与线程都可使用）

import time
import multiprocessing

def new_time():
    """
    返回asc格式的当前时间
    :return:
    """
    return time.asctime(time.localtime(time.time()))

def func(x,y):
    print('func-start', new_time())
    print(multiprocessing.current_process()) # 获取当前运行的进程对象
    print(x+y)
    time.sleep(5)
    print('func-end', new_time())

if __name__ == '__main__':
    print(multiprocessing.current_process()) # 获取当前运行的进程对象

    print('main-start',new_time())

    p1 = multiprocessing.Process(target = func,args=(1,2)) # 实例化一个新的子进程
    p1.start()

    time.sleep(5) # 模拟耗时操作，主进程的任务

    p1.join()  # 等待子进程结束，主要是通过阻塞的方式来等待

print('main-end',new_time())

MainProcess 表示主进程，Process - 1 表示子进程。

3.任务名字

import time
import multiprocessing

def new_time():
    """
    返回asc格式的当前时间
    :return:
    """
    return time.asctime(time.localtime(time.time()))

def func(x,y):
    print('func-start', new_time())
    print(x+y)
    time.sleep(5)
    print('func-end', new_time())

if __name__ == '__main__':
	print('main-start',new_time())
	
	p1 = multiprocessing.Process(target = func,args=(1,2)) # 实例化一个新的子进程
    p1.name = '进程一号' # 获取进程名
    print(p1.name) # 修改属性名，改变进程名
    p1.start()

    time.sleep(5) # 模拟耗时操作，主进程的任务

    p1.join()  # 等待子进程结束，主要是通过阻塞的方式来等待

print('main-end',new_time())

4.终止进程

在正常情况下，主进程的结束，并不会影响子进程，但是也可以在主进程结束之后，强制终止子进程。（注意线程不能终止，只能等待结束）

import time
import multiprocessing

def new_time():
    """
    返回asc格式的当前时间
    :return:
    """
    return time.asctime(time.localtime(time.time()))

def func(x,y):
    print('func-start', new_time())
    # print(multiprocessing.current_process()) # 获取当前运行的进程对象
    print(x+y)
    time.sleep(5)
    print('func-end', new_time())

if __name__ == '__main__':
    # print(multiprocessing.current_process()) # 获取当前运行的进程对象

    print('main-start',new_time())

    p1 = multiprocessing.Process(target = func,args=(1,2)) # 实例化一个新的子进程
    # p1.name = '进程一号' # 获取进程名
    # print(p1.name) # 修改属性名，改变进程名
    p1.start()

    time.sleep(5) # 模拟耗时操作，主进程的任务

    # p1.join()  # 等待子进程结束，主要是通过阻塞的方式来等待

    p1.terminate()

print('main-end',new_time())

二.多任务标识

1.进程（PID）

在Linux中，只要进程一创建，系统就会分配一个pid，在程序运行过程中，pid都不会改变。可以通过pid查看进程对资源的使用情况，也可以通过PID来控制进程的运行。（ pid 一般是在 start（）方法后执行的）

import time
import multiprocessing

def new_time():
    """
    返回asc格式的当前时间
    :return:
    """
    return time.asctime(time.localtime(time.time()))

def func(x,y):
    print('func-start', new_time())
    # print(multiprocessing.current_process()) # 获取当前运行的进程对象
    print(x+y)
    time.sleep(500)
    print('func-end', new_time())

if __name__ == '__main__':
    # print(multiprocessing.current_process()) # 获取当前运行的进程对象

    print('main-start',new_time())

    p1 = multiprocessing.Process(target = func,args=(1,2)) # 实例化一个新的子进程
    print('beform start',p1.pid)
    # p1.name = '进程一号' # 获取进程名
    # print(p1.name) # 修改属性名，改变进程名

    p1.start()
    print('after start',p1.pid)

    time.sleep(5) # 模拟耗时操作，主进程的任务

    # p1.join()  # 等待子进程结束，主要是通过阻塞的方式来等待

    # p1.terminate()

print('main-end',new_time())

可以利用程序的 pid 对程序进行操作，例如使用远程连接工具杀死进程

2.线程（ident）

线程还是在一个进程当中，因此不会有PID。线程由python解释器调度，为了调度方便，会有ident，类似于操作系统中的pid。（ ident 一般也是在 start（）方法后执行的）

import time
import threading


def new_time():
    """
    返回asc格式的当前时间
    :return:
    """
    return time.asctime(time.localtime(time.time()))

def func(x,y):
    print('func-start', new_time())
    print(x+y)
    time.sleep(5)
    print('func-end', new_time())

print('main-start',new_time())

t1 = threading.Thread(target=func,args=(1,2))
print('befor start',t1.ident)
t1.start()
print('after start',t1.ident)

time.sleep(5)
print('main-end',new_time())

3.生命周期（is_alive()）

进程的生命周期开始于 start，实例化之后，进程并没有启动，只有启动之后才开始生命周期。

import time
import multiprocessing

def new_time():
    """
    返回asc格式的当前时间
    :return:
    """
    return time.asctime(time.localtime(time.time()))

def func(x,y):
    print('func-start', new_time())
    # print(multiprocessing.current_process()) # 获取当前运行的进程对象
    print(x+y)
    time.sleep(3)
    print('func-end', new_time())

if __name__ == '__main__':
    # print(multiprocessing.current_process()) # 获取当前运行的进程对象

    # print('main-start',new_time())

    p1 = multiprocessing.Process(target = func,args=(1,2)) # 实例化一个新的子进程
    # print('befor start',p1.pid)
    # p1.name = '进程一号' # 获取进程名
    # print(p1.name) # 修改属性名，改变进程名

    print('befor start',p1.is_alive())
    p1.start()
    print('after start', p1.is_alive())
    # print('after start',p1.pid)

    time.sleep(3) # 模拟耗时操作，主进程的任务

    p1.join()  # 等待子进程结束，主要是通过阻塞的方式来等待
    print('join start', p1.is_alive())

    # p1.terminate()

print('main-end',new_time())

三.守护模式

开启守护模式之后，主进程结束，子进程会自动结束，但前提是每个子进程都需要开启守护模式。只需在实例化子进程时将 daemon 设置为 True。

import time
import multiprocessing


def new_time():
    """
    返回asc格式的当前时间
    :return:
    """
    return time.asctime(time.localtime(time.time()))

def func(x,y):
    print('func-start', new_time())
    print(x+y)
    time.sleep(5)
    print('func-end', new_time())

if __name__ == '__main__':
    print('main-start',new_time())


    p1 = multiprocessing.Process(target = func,args=(1,2),daemon=True) # 实例化一个新的子进程
    p1.start()

    time.sleep(5)
    print('main-end',new_time())

四.面对对象编程

利用多进程实现 redis 数据库的并发

import time
import redis
import multiprocessing

"""
自定义一个进程类
    通过class关键字定一个类（普通的类）
    如果你想要有进程对象的功能以及属性，做继承
    
    继承于进程类（自定义继承类）

"""

def new_time():
    """
    返回asc格式的当前时间
    :return:
    """
    return time.asctime(time.localtime(time.time()))

class RedisProcess(multiprocessing.Process):
    def __init__(self,db,key,values):
        super().__init__()
        self.connect = redis.StrictRedis(db=db) # 连接redis
        self.key = key
        self.values = values

    def set(self):
        """
        插入数据 设置 key和 value
        :return:
        """
        self.connect.set(self.key,self.values)

    def get(self):
        return self.connect.get(self.key)

    def run(self):
        """
        start 方法会自动调用run方法
        start 后，就插入数据，并返回插入的值
        重写run
        :return:
        """
        print('inner-start',new_time())
        print(multiprocessing.current_process)
        self.set()

        print(self.get().decode('utf-8'))
        time.sleep(1) #  模拟耗时操作
        print('inner-end',new_time())

print('outer-start',new_time())
r1 = RedisProcess(1,'yige','18') # 实例化自定义进程类（创建进程，连接redis）
r2 = RedisProcess(2,'liangge','18')

r1.start() # start会自动调用run
r2.start()
print('outer-end',new_time())

附（今日份学习）：

多任务控制：

守护模式：

利用多进程操作 redis 数据库实现并发：