day30 进程

推荐两本书:现代操作系统和操作系统原来,学习好python以后再去研究.

 

并发:任务的切换,保存状态,存在io的是实现空间和时间的 重复利用

操作系统的发展历史:

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

    穿孔卡带的过程：程序员将对应于程序和数据的已穿孔的纸带（或卡片）装入输入机，然后启动输入机把程序和数据输入计算机内存，接着通过控制台开关启动程序针对数据运行；计算完毕，打印机输出计算结果；用户取走结果并卸下纸带（或卡片）后，才让下一个用户上机。

  　手工操作特点：

　　　　（1）用户独占全机。不会出现因资源已被其他用户占用而等待的现象，但资源的利用率低。

　　　　（2）CPU 等待手工操作。CPU的利用不充分。

　　　　（3）没有操作系统的概念。

　　　　（4）所有的程序设计都是直接操控硬件。

 

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

   20世纪50年代后期，出现人机矛盾：手工操作的慢速度和计算机的高速度之间形成了尖锐矛盾，手工操作方式已严重损害了系统资源的利用率（使资源利用率降为百分之几，甚至更低），不能容忍。唯一的解决办法：只有摆脱人的手工操作，实现作业的自动过渡。这样就出现了成批处理。

　　批处理系统：加载在计算机上的一个系统软件，在它的控制下，计算机能够自动地、成批地处理一个或多个用户的作业（这作业包括程序、数据和命令）。

　　特点：

　　　　设计人员、生产人员、操作人员、程序人员和维护人员直接有了明确的分工，计算机被锁在专用空调房间中，由专业操作人员运行，这便是‘大型机’。

　　　　有了操作系统的概念

　　　　有了程序设计语言：FORTRAN语言或汇编语言

   1.联机批处理系统: 首先出现的是联机批处理系统,即作业的输入/输出由cpu来处理

2.脱机批处理系统: 为克服与缓解：高速主机与慢速外设（输入输出设备）的矛盾，提高CPU的利用率，又引入了脱机批处理系统，即输入/输出（input\output，简称I\O操作）脱离主机控制。

卫星机：一台不与主机直接相连而专门用于与输入/输出设备打交道的。

　　　　　　其功能是：

　　　　　　　　（1）从输入机上读取用户作业并放到输入磁带上。

　　　　　　　　（2）从输出磁带上读取执行结果并传给输出机。

　　　　　    这样，主机不是直接与慢速的输入/输出设备打交道，而是与速度相对较快的磁带机发生关系，有效缓解了主机与设备的矛盾。主机与卫星机可并行工作，二者分工明确，可以充分发挥主机的高速计算能力。

      　　　　  脱机批处理系统:20世纪60年代应用十分广泛，它极大缓解了人机矛盾及主机与外设的矛盾。

　　　　　    不足：但目前为止，所有的程序都还是串行执行的，也就是一个程序结束才执行下一个程序，每次主机内存中仅存放一道作业，每当主机中这个运行期间的作业或者说程序发出输入/输出（I/O）请求后，CPU要去高速磁带里读数据，计算结果要往高速磁带里面写数据，那么高速的CPU便处于等待低速的I/O完成状态，CPU并没有完全的运算起来，也可以理解为我要等着你输入或者等着你输出，致使CPU空闲。注意：之前系统的缺点说的是等待用户将程序全部输入进去，等待程序运行结束后输出最终结果的操作。现在说的是程序运行期间发生的输入\输出操作，也就是去高速磁带里面去读取程序数据，然后将输出数据写到高速磁带中，也是耗时的，cpu这段时间内的利用率也是很低的。

　　　　　　 为改善CPU的利用率，又引入了多道程序系统

 

第三代(1955-1965) 多道程序系统(多道是重点*****)

多道程序设计技术: 多道程序设计技术是指在内存同时放若干道程序，使它们在系统中并发执行，共享系统中的各种资源。当一道程序暂停执行时，CPU立即转去执行另一道程序。

 

空间上的复用:将内存分为几个部分,每个部分放入一个程序,这样,同一时间内存中就有了多道程序.

时间上的复用: 当一个程序在等待I/O时,另一个程序可以使用cpu,如果内存中可以同事存放足够多的作业,则cpu的利用率接近100%

分时系统,实时系统和通用操作系统

https://www.cnblogs.com/clschao/articles/9613464.html

 

并行与并发

并行性和并发性 (Concurrence) 是既相似又有区别的两个概念，并行性是指两个或多个事件在同一时刻发生；而并发性是指两个或多个事件在同一时间间隔内发生。在多道程序环境下，并发性是指在一段时间内宏观上有多个程序在同时运行，但在单处理机系统中，每一时刻却仅能有一道程序执行，故微观上这些程序只能是分时地交替执行。倘若在计算机系统中有多个处理机，则这些可以并发执行的程序便可被分配到多个处理机上，实现并行执行，即利用每个处理机来处理一个可并发执行的程序，这样，多个程序便可同时执行。

1.并行:

　　看着像同时运行,其实是任务之间的切换(遇到io切换的会提高代码效率) ,任务切换+保存状态(保存现场)

2.并发:

　　伪并行,看着像同时运行,其实是任务之间的切换(遇到io切换的会提高代码效率) ,任务切换+保存状态(保存现场)

 

 

同步,异步,非阻塞

进程的三种基本状态

1. 就绪(Ready)状态

　　当进程已分配到除 CPU 以外的所有必要资源后，只要再获得 CPU，便可立即执行，进程这时的状态称为就绪状态。在一个系统中处于就绪状态的进程可能有多个，通常将它们排成一个队列，称为就绪队列。

2. 执行状态

　　进程已获得 CPU，其程序正在执行。在单处理机系统中，只有一个进程处于执行状态；在多处理机系统中，则有多个进程处于执行状态。

3. 阻塞状态

　　正在执行的进程由于发生某事件而暂时无法继续执行时，便放弃处理机而处于暂停状态，亦即进程的执行受到阻塞，把这种暂停状态称为阻塞状态，有时也称为等待状态或封锁状态

 

 

同步,异步,阻塞与非阻塞

　　1.同步阻塞形式

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

 

　　2.异步阻塞形式

　　　　如果在排队取餐的人采用的是异步的方式去等待消息被触发（通知），也就是领了一张小纸条，假如在这段时间里他不能做其它的事情，就在那坐着等着，不能玩游戏等，那么很显然，这个人被阻塞在了这个等待的操作上面；异步操作是可以被阻塞住的，只不过它不是在处理消息时阻塞，而是在等待消息通知时被阻塞。

 

　　3.同步非阻塞形式

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

 

　　4.异步非阻塞形式

　　　　效率更高，因为打电话是你(等待者)的事情，而通知你则是柜台(消息触发机制)的事情，程序没有在两种不同的操作中来回切换。比如说，这个人突然发觉自己烟瘾犯了，需要出去抽根烟，于是他告诉点餐员说，排到我这个号码的时候麻烦到外面通知我一下，那么他就没有被阻塞在这个等待的操作上面，自然这个就是异步+非阻塞的方式了。很多人会把同步和阻塞混淆，是因为很多时候同步操作会以阻塞的形式表现出来，同样的，很多人也会把异步和非阻塞混淆，因为异步操作一般都不会在真正的IO操作处被阻塞。

 

进程的创建:

1.multiprocessing 模块

import time

from multiprocessing import Process

 

def f1():

    time.sleep(3)

    print('xxxx')

 

def f2():

    time.sleep(3)

    print('ssss')

 

# f1()

# f2()

 

 

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

if __name__ == '__main__':  #

    # p1 = Process(target=f1,)

    p2 = Process(target=f2,)

    # p1.start()

    p2.start()

 

2.for循环创建进程

import time

from multiprocessing import Process

 

def f1(i):

    time.sleep(3)

    print(i)

 

if __name__ == '__main__':

 

    for i in range(20):

        p1 = Process(target=f1,args=(i,))

        p1.start()

 

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

 

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()

 

4.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('我是主进程!!!')

 

 

 

                                    

推荐两本书:现代操作系统和操作系统原来,学习好python以后再去研究.

 

并发:任务的切换,保存状态,存在io的是实现空间和时间的 重复利用

操作系统的发展历史:

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

    穿孔卡带的过程：程序员将对应于程序和数据的已穿孔的纸带（或卡片）装入输入机，然后启动输入机把程序和数据输入计算机内存，接着通过控制台开关启动程序针对数据运行；计算完毕，打印机输出计算结果；用户取走结果并卸下纸带（或卡片）后，才让下一个用户上机。

  　手工操作特点：

　　　　（1）用户独占全机。不会出现因资源已被其他用户占用而等待的现象，但资源的利用率低。

　　　　（2）CPU 等待手工操作。CPU的利用不充分。

　　　　（3）没有操作系统的概念。

　　　　（4）所有的程序设计都是直接操控硬件。

 

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

   20世纪50年代后期，出现人机矛盾：手工操作的慢速度和计算机的高速度之间形成了尖锐矛盾，手工操作方式已严重损害了系统资源的利用率（使资源利用率降为百分之几，甚至更低），不能容忍。唯一的解决办法：只有摆脱人的手工操作，实现作业的自动过渡。这样就出现了成批处理。

　　批处理系统：加载在计算机上的一个系统软件，在它的控制下，计算机能够自动地、成批地处理一个或多个用户的作业（这作业包括程序、数据和命令）。

　　特点：

　　　　设计人员、生产人员、操作人员、程序人员和维护人员直接有了明确的分工，计算机被锁在专用空调房间中，由专业操作人员运行，这便是‘大型机’。

　　　　有了操作系统的概念

　　　　有了程序设计语言：FORTRAN语言或汇编语言

   1.联机批处理系统: 首先出现的是联机批处理系统,即作业的输入/输出由cpu来处理

2.脱机批处理系统: 为克服与缓解：高速主机与慢速外设（输入输出设备）的矛盾，提高CPU的利用率，又引入了脱机批处理系统，即输入/输出（input\output，简称I\O操作）脱离主机控制。

卫星机：一台不与主机直接相连而专门用于与输入/输出设备打交道的。

　　　　　　其功能是：

　　　　　　　　（1）从输入机上读取用户作业并放到输入磁带上。

　　　　　　　　（2）从输出磁带上读取执行结果并传给输出机。

　　　　　    这样，主机不是直接与慢速的输入/输出设备打交道，而是与速度相对较快的磁带机发生关系，有效缓解了主机与设备的矛盾。主机与卫星机可并行工作，二者分工明确，可以充分发挥主机的高速计算能力。

      　　　　  脱机批处理系统:20世纪60年代应用十分广泛，它极大缓解了人机矛盾及主机与外设的矛盾。

　　　　　    不足：但目前为止，所有的程序都还是串行执行的，也就是一个程序结束才执行下一个程序，每次主机内存中仅存放一道作业，每当主机中这个运行期间的作业或者说程序发出输入/输出（I/O）请求后，CPU要去高速磁带里读数据，计算结果要往高速磁带里面写数据，那么高速的CPU便处于等待低速的I/O完成状态，CPU并没有完全的运算起来，也可以理解为我要等着你输入或者等着你输出，致使CPU空闲。注意：之前系统的缺点说的是等待用户将程序全部输入进去，等待程序运行结束后输出最终结果的操作。现在说的是程序运行期间发生的输入\输出操作，也就是去高速磁带里面去读取程序数据，然后将输出数据写到高速磁带中，也是耗时的，cpu这段时间内的利用率也是很低的。

　　　　　　 为改善CPU的利用率，又引入了多道程序系统

 

第三代(1955-1965) 多道程序系统(多道是重点*****)

多道程序设计技术: 多道程序设计技术是指在内存同时放若干道程序，使它们在系统中并发执行，共享系统中的各种资源。当一道程序暂停执行时，CPU立即转去执行另一道程序。

 

空间上的复用:将内存分为几个部分,每个部分放入一个程序,这样,同一时间内存中就有了多道程序.

时间上的复用: 当一个程序在等待I/O时,另一个程序可以使用cpu,如果内存中可以同事存放足够多的作业,则cpu的利用率接近100%

分时系统,实时系统和通用操作系统

https://www.cnblogs.com/clschao/articles/9613464.html

 

并行与并发

并行性和并发性 (Concurrence) 是既相似又有区别的两个概念，并行性是指两个或多个事件在同一时刻发生；而并发性是指两个或多个事件在同一时间间隔内发生。在多道程序环境下，并发性是指在一段时间内宏观上有多个程序在同时运行，但在单处理机系统中，每一时刻却仅能有一道程序执行，故微观上这些程序只能是分时地交替执行。倘若在计算机系统中有多个处理机，则这些可以并发执行的程序便可被分配到多个处理机上，实现并行执行，即利用每个处理机来处理一个可并发执行的程序，这样，多个程序便可同时执行。

1.并行:

　　看着像同时运行,其实是任务之间的切换(遇到io切换的会提高代码效率) ,任务切换+保存状态(保存现场)

2.并发:

　　伪并行,看着像同时运行,其实是任务之间的切换(遇到io切换的会提高代码效率) ,任务切换+保存状态(保存现场)

 

 

同步,异步,非阻塞

进程的三种基本状态

1. 就绪(Ready)状态

　　当进程已分配到除 CPU 以外的所有必要资源后，只要再获得 CPU，便可立即执行，进程这时的状态称为就绪状态。在一个系统中处于就绪状态的进程可能有多个，通常将它们排成一个队列，称为就绪队列。

2. 执行状态

　　进程已获得 CPU，其程序正在执行。在单处理机系统中，只有一个进程处于执行状态；在多处理机系统中，则有多个进程处于执行状态。

3. 阻塞状态

　　正在执行的进程由于发生某事件而暂时无法继续执行时，便放弃处理机而处于暂停状态，亦即进程的执行受到阻塞，把这种暂停状态称为阻塞状态，有时也称为等待状态或封锁状态

 

 

同步,异步,阻塞与非阻塞

　　1.同步阻塞形式

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

 

　　2.异步阻塞形式

　　　　如果在排队取餐的人采用的是异步的方式去等待消息被触发（通知），也就是领了一张小纸条，假如在这段时间里他不能做其它的事情，就在那坐着等着，不能玩游戏等，那么很显然，这个人被阻塞在了这个等待的操作上面；异步操作是可以被阻塞住的，只不过它不是在处理消息时阻塞，而是在等待消息通知时被阻塞。

 

　　3.同步非阻塞形式

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

 

　　4.异步非阻塞形式

　　　　效率更高，因为打电话是你(等待者)的事情，而通知你则是柜台(消息触发机制)的事情，程序没有在两种不同的操作中来回切换。比如说，这个人突然发觉自己烟瘾犯了，需要出去抽根烟，于是他告诉点餐员说，排到我这个号码的时候麻烦到外面通知我一下，那么他就没有被阻塞在这个等待的操作上面，自然这个就是异步+非阻塞的方式了。很多人会把同步和阻塞混淆，是因为很多时候同步操作会以阻塞的形式表现出来，同样的，很多人也会把异步和非阻塞混淆，因为异步操作一般都不会在真正的IO操作处被阻塞。

 

进程的创建:

1.multiprocessing 模块

import time

from multiprocessing import Process

 

def f1():

    time.sleep(3)

    print('xxxx')

 

def f2():

    time.sleep(3)

    print('ssss')

 

# f1()

# f2()

 

 

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

if __name__ == '__main__':  #

    # p1 = Process(target=f1,)

    p2 = Process(target=f2,)

    # p1.start()

    p2.start()

 

2.for循环创建进程

import time

from multiprocessing import Process

 

def f1(i):

    time.sleep(3)

    print(i)

 

if __name__ == '__main__':

 

    for i in range(20):

        p1 = Process(target=f1,args=(i,))

        p1.start()

 

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

 

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()

 

4.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('我是主进程!!!')