并发编程5 操作系统&进程

一.今日大纲

1.multiprocessing模块简单应用

2.for循环创建进程

3.进程传参方式和创建方式2

4.join方法

5.操作系统基础

二.今日内容

    (1)操作系统简单介绍
        多道技术:(超级重点)
            空间复用
            时间复用
            进程之间是空间隔离的
        分时系统
        实时系统
        通用操作系统(遇到io切换的会提高代码效率),

        并发:又称伪并发,看着像同时运行,其实是任务之间的切换(遇到IO切换的会提高代码效率)
        任务切换+保存状态(保存现场)
        并行:真正的同时在运行,应用的是多核技术(多个cpu)

        进程三状态:就绪(等待操作系统调度去cpu里面执行) 执行 阻塞

        提交任务的方式:同步异步
        任务的执行状态:阻塞非阻塞
            异步:任务的提交方式,多个任务提交出去,同时执行

        同步堵塞:
        异步堵塞:

        同步非堵塞:
        异步非堵塞:

        (这里是开启进程)

    (2)进程的两种创建方式
        Process(target=f1,args=(i,))  kwargs={'形参名为key':值}

    (3)
    #例子
    from multiprocessing import Process

    class MyProcess(Process):  #继承
        def __init(self,n):
            super().__init__()
            self.n=n

        def run(self):
            pass
    if __name__='__main__':
        P=MyProcess(12)
        P.start()

    join方法:主进程等待子进程执行结束再继续执行
             没有join的话,先执行主进程中的内容
    for 循环开启进程
三.详细内容
(1)multiprocessing模块简单应用:

#运行中的程序叫做进程
import time
time.sleep(1)
print('')

#操作系统是大型软件
#操作系统帮助我们调用硬件的

重点代码&重点注释分析
进程的创建方式1

import time
from multiprocessing import Process
def f1():
    time.sleep(3)
    print('xxx')
def f2():
    time.sleep(3)
    print('sss')
#f1()
#f2()
#重点理解:windows系统下必须写main,因为windows系统创建子进程的方式决定的,开启一个子进程,
# 这个子进程会copy一份主进程的所有代码,并且机制类似于import引入,这样就容易导致引入代码的时候,
# 被引入的代码中的可执行程序被执行,导致递归开始进程,会报错
if __name__=='__main__':
    p1=Process(target=f1,)  #子进程相当于copy主进程的内容一份
    p2=Process(target=f2,)
    p1.start()              #先调用主程序内的,再执行自己的并且,
                            # 所有start必须执行完,才可以执行,
    p2.start()

    time.sleep(3)  #仅限于我们的程序
    # p1.join()   #意思是子进程执行完才执行主进程
    # p2.join()
    print('我是主进程!!')

'''
不注释
p1.join()
p2.join():
结果:
xxx
sss
我是主进程!!

注释
p1.join()
p2.join():
结果:
我是主进程!!
xxx
sss
'''

(2)for循环创建进程

import time
from multiprocessing import Process

def f1(i):
    time.sleep(1)
    print(i)

if __name__=='__main__':

    for i  in  range(20):
        p1=Process(target=f1,args=(i,))  #传参
        p1.start()

注意:上边得到的结果是:0-19的20行数字,并且不是按照有序排列的

(3)演示两种传参方式

演示两种传参方式
方式一:
# import time
# from multiprocessing import Process
# def f1(i):
#     time.sleep(3)
#     print(i)
# if __name__=='__main__':
#         p1=Process(target=f1,args=('冬瓜与黄瓜',))  #传参
#         p1.start()  #给操作系统发送一个创建进程的信号,后续进程的创建都是操作系统的事

方式二
# import time
# from multiprocessing import Process
#
# def f1(i):
#     time.sleep(3)
#     print(i)
# if __name__=='__main__':
#     p1=Process(target=f1,kwargs={'i':'大牛'})  #传参//创建进程对象
#     p1.start()  #给操作系统发送一个创建进程的信号,后续进程的创建都是操作系统的事

案例:

from multiprocessing import  Process
class MyProcess(Process):
    def run(self):
        print('宝宝')
if __name__=='__main__':
    p1=MyProcess()
    p1.start()

(4)进程的创建方式2

#传参:需要重新写一个init方法
from multiprocessing import Process
class MyProcess(Process):
    def __init__(self,n):
        super().__init__()  #先执行父类的方法
                            #别忘了执行父类的init
        ''''''
        '''
        没有上面的一句话,会报错,原因是下面,所以必须继承父类的参数
        assert self._popen is None, 'cannot start a process twice'
        AttributeError: 'MyProcess' object has no attribute '_popen'
        '''
        self.n=n        #自己定义的形式参数n

    def run(self):
        print('宝宝and%s不可告人的事情'%self.n)
if __name__=='__main__':
    p1=MyProcess('搞忘')
    p1.start()

(5)join方法

import time
from multiprocessing import Process
def f1():
    time.sleep(2)
    print('xxxx')
def f2():
    time.sleep(2)
    print('ssss')
# f1()
# f2()
if __name__ == '__main__':

    p1 = Process(target=f1,)
    p1.start()
    p1.join()  # 主进程等待子进程运行完才继续执行

    print('开始p2拉')      #这个地方相当于主进程

    p2 = Process(target=f2,)
    p2.start()
    p2.join()
    print('我要等了...等我的子进程...')
    time.sleep(3)
    print('我是主进程!!!')

'''
如果把两个join()方法注释掉,结果是:
开始p2拉
我要等了...等我的子进程...
xxxx
ssss
我是主进程!!!

不注释的结果是:
xxxx
开始p2拉
ssss
我要等了...等我的子进程...
我是主进程!!!