Python全栈最全学习之路-网路编程（四）

线程与进程补充

一 、多运行任务控制

1、等待子任务结束

join
进程或者线程添加join方法之后，会等待子任务结束，如果没有结束则会阻塞，知道子任务结束，因此join一般都是放在程序的最后面

import time
import multiprocessing
def new_time():
    return time.asctime(time.localtime())
def func():
    print('inner-start:',new_time())
    time.sleep(10)
    print('inner-end:',new_time())
print('outer--start',new_time())
p1 = multiprocessing.Process(target=func) #实例化
p1.start() #开启新的进程-子进程
p1.join() #等待子进程结束
time.sleep(5)
print('outer-end',new_time())

2、获取当前进程

获取进程
在进程内容获取当前进程，方便查找问题

import time
import multiprocessing
print(multiprocessing.current_process()) #获取进程对象
def new_time():
    return time.asctime(time.localtime())
def func():
    print('inner--start:',new_time())
    print(multiprocessing.current_process())
    time.sleep(5)
    print('inner--end:',new_time())
print('outer--start',new_time())
p1 = multiprocessing.Process(target=func) #实例化
p1.start() #开启新的进程-子进程
time.sleep(5)
print('outer--end',new_time())

3、任务名字

import multiprocessing
# 在初始化的时候定义其名字
p1 = multiprocessing.Process(name='Process name one')
print(p1)
print(p1.name)
# 在操作过程中也可以直接改名字
p1.name = 'new name 2'
print(p1.name)

添加与更改名字
修改与添加用户的名字，起到表示作用

4、终止任务

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

import time
import multiprocessing
def new_time():
    return time.asctime(time.localtime())
def func():
    print('inner--start:',new_time())
    time.sleep(5)
    print('inner--end:',new_time())
print('outer--start',new_time())
p1 = multiprocessing.Process(target=func) #实例化
p1.start() #开启新的进程-子进程
time.sleep(3) # 主进程休眠
p1.terminate() # 终止子进程，但是线程不能被终止，只能等待结束
print('outer--end',new_time())

二、多任务标识

1、进程的pid

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

import time
import multiprocessing
def new_time():
    return time.asctime(time.localtime())
def func():
    print('inner--start:',new_time())
    time.sleep(5)
    print('inner--end:',new_time())
print('outer--start',new_time())
p1 = multiprocessing.Process(target=func) #实例化
print('befor start:',p1.pid)
p1.start() #开启新的进程-子进程
print('after start:',p1.pid)
time.sleep(3) # 主进程休眠1
print('outer--end',new_time())

2、线程ident

ident
线程还是在一个进程当中，因此不会又PID。
线程由Python解释器调度，为了调度方便，会有ident，类似于操作系统中的pid

import time
import threading
def new_time():
    return time.asctime(time.localtime())
def func():
    print('inner--start:',new_time())
    time.sleep(5)
    print('inner--end:',new_time())
print('outer--start',new_time())
t1 = threading.Thread(target=func) #实例化
print('befor start:',t1.ident) # 获取线程ident
t1.start() #开启新的进程-子进程
print('after start:',t1.ident)
time.sleep(3) # 主进程休眠1
print('outer--end',new_time())

3、生存周期

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

import time
import multiprocessing
def new_time():
    return time.asctime(time.localtime())
def func():
    print('inner--start:',new_time())
    time.sleep(5)
    print('inner--end:',new_time())
print('outer--start',new_time())
p1 = multiprocessing.Process(target=func) #实例化
print('befor start:',p1.is_alive()) # 查看是否存在
p1.start() #开启新的进程-子进程
print('after start:',p1.is_alive())
time.sleep(3) # 主进程休眠
p1.join()
print('end:',p1.is_alive())
print('outer--end',new_time())

三、守护模式

1、守护模式

守护模式
开启守护模式之后，主进程结束，子进程会自动结束

import time
import multiprocessing
def new_time():
    return time.asctime(time.localtime())
def func():
    print('inner--start:',new_time())
    time.sleep(5)
    print('inner--end:',new_time())
print('outer--start',new_time())
p1 = multiprocessing.Process(target=func,daemon=True) #实例化,开启守护模式
p1.start() #开启新的进程-子进程
time.sleep(3) # 主进程休眠
print('outer--end',new_time())

四、面向对象编程

1、面向对象编程

面向对象编程
在使用多进程或者多线程时，对应模块可以直接使用，也可以继承之后，定制使用

import multiprocessing
import redis
class RedisProcess(multiprocessing.Process):
    def __init__(self,db,key,values):
        super().__init__()
        self.connect = redis.Redis(db=db) # 连接redis
        self.key = key
        self.value = values
    def set(self): # 设置键和值
        self.connect.set(self.key,self.values)
    def get(self): # 获取键和值
        return self.connect.get(self.key)
    def run(self): # start 时会自动调用 run 方法
        print(multiprocessing.current_process())
        self.set()
myredis = RedisProcess(0,'ba1','test1')
myredis.start()