python 计算机发展史,线程Process使用 for循环创建 2种传参方式 jion方法 __main_

########################总结##################

#一 操作系统的作用：
    1：隐藏丑陋复杂的硬件接口，提供良好的抽象接口
    2：管理、调度进程，并且将多个进程对硬件的竞争变得有序
 
#二 多道技术：
 
　　空间复用:(把多个进程放到内存中,不再是只放一个进程了) 物理隔离
 
   时间复用:(将程序中的io阻塞时间充分的利用起来了,遇到io自动切换)

并发:伪并行,多个程序看上去同时运行,其实是多个程序之间切换执行

程序切换 + 保存状态

并行:真正的同时在运行,应用多核

异步非阻塞:多个任务同时执行,没有阻塞

　　（1）就绪(Ready)状态

　　当进程已分配到除CPU以外的所有必要的资源，只要获得处理机便可立即执行，这时的进程状态称为就绪状态。

　　（2）执行/运行（Running）状态当进程已获得处理机，其程序正在处理机上执行，此时的进程状态称为执行状态。

　　（3）阻塞(Blocked)状态正在执行的进程，由于等待某个事件发生而无法执行时，便放弃处理机而处于阻塞状态。引起进程阻塞的事件可有多种，例如，等待I/O完成、申请缓冲区不能满足、等待信件(信号)等。

同步和异步

所谓同步就是一个任务的完成需要依赖另外一个任务时，只有等待被依赖的任务完成后，依赖的任务才能算完成，这是一种可靠的任务序列。要么成功都成功，失败都失败，两个任务的状态可以保持一致。

所谓异步是不需要等待被依赖的任务完成，只是通知被依赖的任务要完成什么工作，依赖的任务也立即执行，只要自己完成了整个任务就算完成了。至于被依赖的任务最终是否真正完成，依赖它的任务无法确定，所以它是不可靠的任务序列。

第一种 ：选择排队等候；
第二种 ：选择取一个小纸条上面有我的号码，等到排到我这一号时由柜台的人通知我轮到我去办理业务了；

阻塞与非阻塞

继续上面的那个例子，不论是排队还是使用号码等待通知，如果在这个等待的过程中，等待者除了等待消息通知之外不能做其它的事情，那么该机制就是阻塞的，表现在程序中,也就是该程序一直阻塞在该函数调用处不能继续往下执行。

相反，有的人喜欢在银行办理这些业务的时候一边打打电话发发短信一边等待，这样的状态就是非阻塞的，因为他(等待者)没有阻塞在这个消息通知上，而是一边做自己的事情一边等待

同步阻塞形式

　　效率最低。拿上面的例子来说，就是你专心排队，什么别的事都不做。

异步阻塞形式

　　如果在银行等待办理业务的人采用的是异步的方式去等待消息被触发（通知），也就是领了一张小纸条，假如在这段时间里他不能离开银行做其它的事情，那么很显然，这个人被阻塞在了这个等待的操作上面；

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

同步非阻塞形式

　　实际上是效率低下的。

　　想象一下你一边打着电话一边还需要抬头看到底队伍排到你了没有，如果把打电话和观察排队的位置看成是程序的两个操作的话，这个程序需要在这两种不同的行为之间来回的切换，效率可想而知是低下的。

异步非阻塞形式

　　效率更高，

　　因为打电话是你(等待者)的事情，而通知你则是柜台(消息触发机制)的事情，程序没有在两种不同的操作中来回切换。

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

很多人会把同步和阻塞混淆，是因为很多时候同步操作会以阻塞的形式表现出来，同样的，很多人也会把异步和非阻塞混淆，因为异步操作一般都不会在真正的IO操作处被阻塞。

模块的使用

import time
from multiprocessing import  Process #mou t p ruang sai seng
def f1():
    time.sleep(3)
    print('')
def f2():
    time.sleep(3)
    print('')
if __name__=='__main__':
    p1=Process(target=f1,)
    p2=Process(target=f2,)
    p1.start()
    p2.start()
###################

222222
111111

for 循环创建进程

import time
from multiprocessing import Process
 
def f1(i):
    time.sleep(2)
    print(i)
if __name__ == '__main__':
    for i in range(20):
        p1=Process(target=f1,args=(i,))
        p1.start()
####################

1
2
0
6
10
7
4
12
5
16
8
18
9
17
15
13
11
14
3
19

进程(传参方法)和创建方式

##方法一
from multiprocessing import Process
#演示两种传参方式
def f1(n):
    print(n)
 
if __name__=='__main__':
    # p1=Process(target=f1,args=('大力出奇迹'))
    p1 = Process(target=f1, kwargs={'n': '大力'})  # 创建进程对象
    p1.start()#给操作系统发送了一个创建进程的信号,后续进程的创建都是操作系统的事儿了
###############
大力

#进程的创建方式2
class MyProcess(Process):
    def __init__(self,n):
        super().__init__()  #别忘了执行父类的init
        self.n = n
 
    def run(self):
        print('宝宝and%s不可告人的事情'%self.n)
if __name__ == '__main__':
    p1 = MyProcess('高望')
    p1.start()
##################
宝宝and高望不可告人的事情

join 方法

import time
from multiprocessing import Process
def f1():
    time.sleep(2)
    print('')
def f2():
    time.sleep(2)
    print('')
if __name__ == '__main__':
    p1=Process(target=f1,)
    p1.start()
    p1.join()#主进程等子进程运行完成才能执行
    print('开始p2拉')
    p2 = Process(target=f2,)
    p2.start()
    p2.join()
    print('我要等了...等我的子进程...')
    print('我是主进程!!!')
 
######################

111111111
开始p2拉
22222222
我要等了...等我的子进程...
我是主进程!!!

main

#windows系统下必须写main,因为windows系统创建子进程的方式决定的,开启一个子进程,这个子进程 会copy一份主进程的所有代码,并且机制类似于import引入,这样就容易导致引入代码的时候,被引入的代码中的可执行程序被执行,导致递归开始进程,会报错
if __name__ == '__main__':  #
    # p1 = Process(target=f1,)
    p2 = Process(target=f2,)
    # p1.start()
    p2.start()