python-day30(进程 验证空间隔离)

一. 进程

　　进程:我们自己在python文件中写了一些代码，这叫做程序，运行这个python文件的时候，

　　　　　　这叫做进程。

　　

　　进程调度: 遵循 操作系统 规定的法则, 调度算法  链接

　　并发: 是伪并行, 即看起来是同时运行. 单个CPU+多道技术就可以实现并发,(并行也属于并发)

　　并行: 同时运行, 只有具备多个cpu才能实现并行

　　

　　同步异步阻塞非阻塞(重点)

　　同步: 其实就是一个程序结束才执行另外一个程序,串行的

　　异步: 异步是不需要等待被依赖的任务完成, 只是通知被依赖的任务要完成什么工作,依赖的任务也立即执行,只要自己完成了整个任务就算完成了.

　　

　　阻塞/非阻塞

排队等待的时候,等待者除了等待消息通知之外不能做其他的事情,
那么该机制就是阻塞的

等待者没有阻塞在这个消息通知上,而是一边做自己的事情一边等待,
这是非阻塞

　　1.  同步阻塞形式

　　　　效率最低,就是专心排队, 什么别的事都不做

　　2. 异步阻塞形式

　　　　取餐的人领了一张小纸条,假如在这等待的时间里他不能做其他的事情,就坐那里等着,

　　　　　　这个人被阻塞在了这个等待的操作上面;

　　　　异步操作是可以被阻塞住的,只不过他不是在处理消息是阻塞,而是在等待消息通知时被阻塞

　　3. 同步非阻塞形式

　　　　实际上是效率低下的

　　　　想象一下你一边打着电话一边还需要抬头看 到底排到你了没有, 如果把打电话和观察队伍的位置

　　　　看成是程序的两个操作的话, 这个程序需要在这两种不同的行为之间来回切换,效率可想而知是

　　　　　　低下的

　　4. 异步非阻塞形式

　　　　效率更高

　　　　比如说，这个人突然发觉自己烟瘾犯了，需要出去抽根烟，于是他告诉点餐员说，排到我这个号码的时候麻烦到外面通知我一下，那么他就没有被阻塞在这个等待的操作上面，自然这个就是异步+非阻塞的方式了。

　　

　　操作系统发展史简单介绍(略过)

　　第一代(1940~1955) 手工操作 ---- 穿孔卡片

　　第二代(1955~1965) 磁带储存 ---- 批处理系统

　　　　1. 联机批处理

　　　　2. 脱机批处理系统

　　第三代(1955~1965) 多道程序系统(********)

　　　　1. 多道程序设计技术

　　　　2. 多道批处理系统

　　　　3. 分时系统

　　　　4. 实时系统

　　　　5. 通用操作系统

　　第N代(1980~至今)  现代计算机

　　　　1. 个人计算机操作系统

　　　　2. 网络操作系统

　　　　3. 分布式操作系统

#一 操作系统的作用：
    1：隐藏丑陋复杂的硬件接口，提供良好的抽象接口
    2：管理、调度进程，并且将多个进程对硬件的竞争变得有序

#二 多道技术：
    1.产生背景：针对单核，实现并发
    ps：
    现在的主机一般是多核，那么每个核都会利用多道技术
    有4个cpu，运行于cpu1的某个程序遇到io阻塞，会等到io结束再重新调度，会被调度到4个
    cpu中的任意一个，具体由操作系统调度算法决定。
    
    2.空间上的复用：如内存中同时有多道程序
    3.时间上的复用：复用一个cpu的时间片
       强调：遇到io切，占用cpu时间过长也切，核心在于切之前将进程的状态保存下来，这样
            才能保证下次切换回来时，能基于上次切走的位置继续运行

二. 进程的两种创建方法(**********) multiprocess模块

　　进程的创建

#当前文件名称为test.py
# from multiprocessing import Process
#
# def func():
#     print(12345)
#
# if __name__ == '__main__': #windows 下才需要写这个，这和系统创建进程的机制有关系，不用深究，记着windows下要写就好啦
#     #首先我运行当前这个test.py文件，运行这个文件的程序，那么就产生了进程，这个进程我们称为主进程
#
#     p = Process(target=func,) #将函数注册到一个进程中，p是一个进程对象，此时还没有启动进程，只是创建了一个进程对象。并且func是不加括号的，因为加上括号这个函数就直接运行了对吧。
#     p.start() #告诉操作系统，给我开启一个进程，func这个函数就被我们新开的这个进程执行了，而这个进程是我主进程运行过程中创建出来的，所以称这个新创建的进程为主进程的子进程，而主进程又可以称为这个新进程的父进程。
　　　　　　　　　 #而这个子进程中执行的程序，相当于将现在这个test.py文件中的程序copy到一个你看不到的python文件中去执行了，就相当于当前这个文件，被另外一个py文件import过去并执行了。
　　　　　　　　　 #start并不是直接就去执行了，我们知道进程有三个状态，进程会进入进程的三个状态，就绪，（被调度，也就是时间片切换到它的时候）执行，阻塞，并且在这个三个状态之间不断的转换，等待cpu执行时间片到了。
#     print('*' * 10) #这是主进程的程序，上面开启的子进程的程序是和主进程的程序同时运行的，我们称为异步

　　进程的创建(第二种方法)

from multiprocessing import Process
import os

class MyProcess(Process): #自己写一个类，继承Process类
    #我们通过init方法可以传参数，如果只写一个run方法，那么没法传参数，因为创建对象的是传参就是在init方法里面，面向对象的时候，我们是不是学过
    def __init__(self,person):
        super().__init__()
        self.person=person
    def run(self):
        print(os.getpid())
        print(self.pid)
        print(self.pid)
        print('%s 正在和女主播聊天' %self.person)
    # def start(self):
    #     #如果你非要写一个start方法，可以这样写，并且在run方法前后，可以写一些其他的逻辑
    #     self.run()
if __name__ == '__main__':
    p1=MyProcess('Jedan')
    p2=MyProcess('太白')
    p3=MyProcess('alexDSB')

    p1.start() #start内部会自动调用run方法
    p2.start()
    # p2.run()
    p3.start()


    p1.join()
    p2.join()
    p3.join()

 

三. 进程之间是空间隔离的(验证)

#我们说进程之间的数据是隔离的，也就是数据不共享，看下面的验证
from multiprocessing import Process
n=100 #首先我定义了一个全局变量，在windows系统中应该把全局变量定义在if __name__ == '__main__'之上就可以了
def work():
    global n
    n=0
    print('子进程内: ',n)

if __name__ == '__main__':
    p=Process(target=work)
    p.start()
    p.join() #等待子进程执行完毕，如果数据共享的话，我子进程是不是通过global将n改为0了，但是你看打印结果，主进程在子进程执行结束之后，仍然是n=100，子进程n=0，说明子进程对n的修改没有在主进程中生效，说明什么？说明他们之间的数据是隔离的，互相不影响的
    print('主进程内: ',n)

#看结果：
# 子进程内:  0
# 主进程内:  100

四. os.getpid() os.getppid()

#os.getpid()  获取自己进程的ID号
#os.getppid() 获取自己进程的父进程的ID号

 

join(只有在join的地方才会阻塞住，将子进程和主进程之间的异步改为同步)

from multiprocessing import Process

def func():
    print(12345)

if __name__ == '__main__':
    p = Process(target=func)
    p.start()
    p.join()#阻塞住,将子进程和主进程之间的异步改为同步
    print('*'*10)

 进程 

　　并发 = 任务切换 + 保存状态

转自cls超