高级应用：进程和线程的补充

 

一：多任务运行控制

1.1 join 方法：

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

        eg：关闭浏览器，会提示是否关闭所有界面。

import time
import multiprocessing

#现在时间方法：
def new_time():
    return time.strftime('%Y-%m-%d %H:%M:%S')

def func():
    print('内部开始时间',new_time())
    time.sleep(5)
    print('内部开始时间',new_time())

if __name__ == '__main__':
    print('外部开始时间',new_time())
    p1 =multiprocessing.Process(target=func) #子进程：内部开始时间
    p1.start()
    time.sleep(5)
    p1.join()       #主任务等待子任务结束在结束
    print('外部开始时间',new_time())

       

1.2终止任务

     终止任务： 在正常情况下，主进程的结束，并不会影响子进程，但是也可以在主进程结束之后，强制终止子进程

        注意：线程不能终止，只能等待结束

import time
import multiprocessing

#现在时间方法：
def new_time():
    return time.strftime('%Y-%m-%d %H:%M:%S')

def func():
    print('内部开始时间',new_time())
    time.sleep(5)
    print('内部开始时间',new_time())

if __name__ == '__main__':
    print('外部开始时间',new_time())
    p1 =multiprocessing.Process(target=func) #子进程：内部开始时间
    p1.start()
    time.sleep(5)
    # p1.join()
    p1.terminate()  #强制终止子进程
    print('外部开始时间',new_time())

1.3 join和terminate 在开发时的判断

import time
import multiprocessing

#现在时间方法：
def new_time():
    return time.strftime('%Y-%m-%d %H:%M:%S')

def func():
    print('内部开始时间',new_time())
    time.sleep(10)
    print('内部开始时间',new_time())

if __name__ == '__main__':
    print('外部开始时间',new_time())
    p1 =multiprocessing.Process(target=func) #子进程：内部开始时间
    p1.start()
    time.sleep(5)
    res = input('是否继续执行子任务N/Y')
    if res == 'Y':  #主进程等待子进程运行结束后在结束
        p1.join()
    elif res =='N':
        p1.terminate()
    else:
        print('请输入准确的指令')
    # p1.join()
    # p1.terminate()  #强制终止子进程
    print('外部开始时间',new_time())

二：获取当前进程：

        2.1 获取当前进程对象：multiprocessing.current_process()

        作用：很方便的看到每个进程出现的问题

import time
import multiprocessing

print(multiprocessing.current_process())  #获取当前进程对象
#现在时间方法：
def new_time():
    return time.strftime('%Y-%m-%d %H:%M:%S')

def func():
    print('内部开始时间',new_time())
    print(multiprocessing.current_process())
    time.sleep(10)
    print('内部开始时间',new_time())

if __name__ == '__main__':
    print('外部开始时间',new_time())
    p1 =multiprocessing.Process(target=func) #子进程：内部开始时间
    p1.start()
    time.sleep(5)
    # res = input('是否继续执行子任务N/Y')
    # if res == 'Y':  #主进程等待子进程运行结束后在结束
    #     p1.join()
    # elif res =='N':
    #     p1.terminate()
    # else:
    #     print('请输入准确的指令')
    # # p1.join()
    # # p1.terminate()  #强制终止子进程
    print('外部开始时间',new_time())

         2.2 获取进程pid 

        作用：在代码的书写，软件的开发，用的Linux 系统中，知道进程的pid之后，用 kill 命令可以杀掉当前的进程的方法

import time
import multiprocessing

# print(multiprocessing.current_process())  #获取当前进程对象
#现在时间方法：
def new_time():
    return time.strftime('%Y-%m-%d %H:%M:%S')

def func():
    print('内部开始时间',new_time())
    # print(multiprocessing.current_process())
    time.sleep(10)
    print('内部开始时间',new_time())

if __name__ == '__main__':
    print('外部开始时间',new_time())
    p1 =multiprocessing.Process(target=func) #子进程：内部开始时间
    print('before_start',p1.pid)
    p1.start()
    print('after_start', p1.pid)
    time.sleep(5)
    # res = input('是否继续执行子任务N/Y')
    # if res == 'Y':  #主进程等待子进程运行结束后在结束
    #     p1.join()
    # elif res =='N':
    #     p1.terminate()
    # else:
    #     print('请输入准确的指令')
    # # p1.join()
    # # p1.terminate()  #强制终止子进程
    print('外部开始时间',new_time())

 2.3 获取线程 ident

import time
import multiprocessing
import threading

# print(multiprocessing.current_process())  #获取当前进程对象
#现在时间方法：
def new_time():
    return time.strftime('%Y-%m-%d %H:%M:%S')

def func():
    print('内部开始时间',new_time())
    # print(multiprocessing.current_process())
    time.sleep(10)
    print('内部开始时间',new_time())

if __name__ == '__main__':
    print('外部开始时间',new_time())
    p1 = threading.Thread(target=func)  #实例化对象
    print('before_start',p1.ident)  #获取线程ident
    p1.start()    #开启新的线程 ——子线程
    print('after_start', p1.ident)
    time.sleep(5)  #主进程休眠
    # res = input('是否继续执行子任务N/Y')
    # if res == 'Y':  #主进程等待子进程运行结束后在结束
    #     p1.join()
    # elif res =='N':
    #     p1.terminate()
    # else:
    #     print('请输入准确的指令')
    # # p1.join()
    # # p1.terminate()  #强制终止子进程
    print('外部开始时间',new_time())

三：生命周期

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

        作用：查看进程有没有在做事情，在做事情则是Ture 否则False

import time
import multiprocessing
import threading

# print(multiprocessing.current_process())  #获取当前进程对象
#现在时间方法：
def new_time():
    return time.strftime('%Y-%m-%d %H:%M:%S')

def func():
    print('内部开始时间',new_time())
    # print(multiprocessing.current_process())
    time.sleep(10)
    print('内部开始时间',new_time())

if __name__ == '__main__':
    print('外部开始时间',new_time())
    p1 = threading.Thread(target=func)#子进程：内部开始时间
    print('before_start',p1.is_alive())
    p1.start()
    print('after_start', p1.is_alive())
    time.sleep(5)
    # res = input('是否继续执行子任务N/Y')
    # if res == 'Y':  #主进程等待子进程运行结束后在结束
    #     p1.join()
    # elif res =='N':
    #     p1.terminate()
    # else:
    #     print('请输入准确的指令')
    # # p1.join()
    # # p1.terminate()  #强制终止子进程
    print('外部开始时间',new_time())

四：守护模式

        开启守护模式之后，主进程结束，子进 程会自动结束。他的写法的是在进程实例化对象中添加 daemon = Ture

        守护模式跟terminate的区别：

                共同点：主进程结束之后，强制终止子进程

                不同点：守护模式是殉情模式（自杀），terminate是他杀（谋杀）

import time
import multiprocessing
import threading

# print(multiprocessing.current_process())  #获取当前进程对象
#现在时间方法：
def new_time():
    return time.strftime('%Y-%m-%d %H:%M:%S')

def func():
    print('内部开始时间',new_time())
    # print(multiprocessing.current_process())
    time.sleep(10)
    print('内部开始时间',new_time())

if __name__ == '__main__':
    print('外部开始时间',new_time())
    p1 = threading.Thread(target=func,daemon=True)# 守护模式开始
    # print('before_start',p1.is_alive())
    p1.start()
    # print('after_start', p1.is_alive())
    time.sleep(5)
    # res = input('是否继续执行子任务N/Y')
    # if res == 'Y':  #主进程等待子进程运行结束后在结束
    #     p1.join()
    # elif res =='N':
    #     p1.terminate()
    # else:
    #     print('请输入准确的指令')
    # # p1.join()
    # # p1.terminate()  #强制终止子进程
    print('外部开始时间',new_time())

附加：

补充上节课没讲完知识点：

进程注意点：1.进程之间执行是无序的 ，进程是由操作系统决定，操作系统调用哪个进程，哪个进程就会执行，没有调用的就不执行。  2.进程之间不共享全局变量  3.主进程程会等待所有的子进程执行结束再结束。

线程注意点：1.线程之间执行是无序的 ，它是由CPU调度决定的，CPU调用的哪个线程，哪个线程就会执行。没有调度的就不能执行 2.主线程会等待所有的子线程执行结束再结束  3.线程之间共享全局变量 

拓展功能：面向对象编程和进程和线程的结合使用

redis：

 拓展：

在终端切换硬盘：D:

切换到那个路径下面:   cd+文件名

查看文件夹有哪些目录：  ls