python3.6入门到高阶(全栈) day30 进程

1、操作系统了解

　　现代的计算机系统主要是由一个或者多个处理器，主存，硬盘，键盘，鼠标，显示器，打印机，网络接口及其他输入输出设备组成, 这些都是硬件设备, 而操作系统就是负责调用这些硬件为用户服务的.

　　操作系统位于计算机硬件与应用软件之间，本质也是一个软件. 

　　精简的说的话，操作系统就是一个协调、管理和控制计算机硬件资源和软件资源的控制程序。

2、操作系统发展中几个比较重要的系统阶段

　　多道程序系统

　　　　 多道程序设计技术，就是指允许多个程序同时进入内存并运行。即同时把多个程序放入内存，并允许它们交替在CPU中运行，它们共享系统中的各种硬、软件资源。当一道程序因I/O请求而暂停运行时，CPU便立即转去运行另一道程序。

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

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

　　　　缺点: 空间复用：程序之间的内存没有确切分割，不由操作系统控制。如果内存彼此不分割，则一个程序可以访问另外一个程序的内存。

　　　　　　  时间复用：必须等某个程序出现I/O阻塞, cpu才会进行切换, 否则该程序一直占用cpu资源. 

　　分时系统(交互式系统)

　　　　把处理机的运行时间分成很短的时间片，按时间片轮流把处理机分配给各联机作业使用。若某个作业在分配给它的时间片内不能完成其计算，则该作业暂时中断，把处理机让给另一作业使用，等待下一轮时再继续其运行。由于计算机速度很快，作业运行轮转得很快，给每个用户的印象是，好象他独占了一台计算机。而每个用户可以通过自己的终端向系统发出各种操作控制命令，在充分的人机交互情况下，完成作业的运行。

　　　　特点: 

　　　　　　（1）多路性。若干个用户同时使用一台计算机。微观上看是各用户轮流使用计算机；宏观上看是各用户并行工作.

　　　　　　（2）交互性。用户可根据系统对请求的响应结果，进一步向系统提出新的请求。这种能使用户与系统进行人机对话的工作方式，又被称为交互式系统.

　　　　　　（3）及时性。系统可对用户的输入及时作出响应.

　　　　　　（4）独立性。用户之间可以相互独立操作，互不干扰。系统保证各用户程序运行的完整性，不会发生相互混淆或破坏现象.

　　　　缺点: 

　　　　　　计算机的效率变低 ( 分时系统的分时间片工作，在没有遇到IO操作的时候就用完了自己的时间片被切走了，这样的切换工作其实并没有提高cpu的效率，反而使得计算机的效率降低了。为什么下降了呢？因为CPU需要切换，并且记录每次切换程序执行到了哪里，以便下次再切换回来的时候能够继续之前的程序，虽然我们牺牲了一点效率，但是却实现了多个程序共同执行的效果，这样你就可以在计算机上一边听音乐一边聊qq了 ) 。

3、什么是进程

　　进程: 就是执行中的程序. 当cpu调用程序计算时才是一个进程.　

　　特点: 

　　　　动态性：进程的实质是程序在多道程序系统中的一次执行过程，进程是动态产生，动态消亡的　　

　　　　并发性：任何进程都可以同其他进程一起并发执行

　　　　独立性：进程是一个能独立运行的基本单位，同时也是系统分配资源和调度的独立单位；

　　　　异步性：由于进程间的相互制约，使进程具有执行的间断性，即进程按各自独立的、不可预知的速度向前推进

　　　　结构特征：进程由程序、数据和进程控制块三部分组成。

　　　　多个不同的进程可以包含相同的程序：一个程序在不同的数据集里就构成不同的进程，能得到不同的结果；但是执行过程中，程序不能发生改变。

4、并发与并行

　　并发：是伪并行，即看起来是同时运行。单个cpu+多道技术就可以实现并发，（并行也属于并发）

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

　　内存中同时存入多道（多个）程序，cpu从一个进程快速切换到另外一个，使每个进程各自运行几十或几百毫秒，这样，虽然在某一个瞬间，一个cpu只能执行一个任务，但在1秒内，cpu却可以运行多个进程，这就给人产生了并行的错觉，即伪并行，以此来区分多处理器操作系统的真正硬件并行（多个cpu共享同一个物理内存）

5、同步/异步/阻塞/非阻塞

　　程序的三个状态

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

　　　　执行/运行状态: 当进程已获得cup，其程序正在cpu上执行，此时的进程状态称为执行状态。

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

　　

　　同步: 第一个程序运行完才运行第二个程序, 串行.

　　异步: 不需要等待第一个程序结束, 就可以运行第二个程序. 

　　阻塞: 程序在等待某个指令之外不能做其他的事, 这个机制就是阻塞.

　　非阻塞: 程序在等待某个指令之外, 还能做其他的事情, 即非阻塞. 

　　同步阻塞: 程序被阻塞着, 除了等不能干其他的事情, 效率最低.

　　异步阻塞: 异步操作是可以被阻塞的, 不过不是在处理消息时阻塞, 而是在等待消息通知时被阻塞, 效率较低.

　　同步非阻塞: 程序没有阻塞, 但要在两种不同的行为之间来回切换, 效率较低. 

　　异步非阻塞: 可以干其他的事情而且不会被阻塞.

6、创建进程的两种方式

　　创建Process类的进程对象.

1 import os
 2 from multiprocessing import Process
 3 
 4 def func1(a):
 5     print(a)
 6     print("执行func1函数")
 7     print("子进程的进程号-----",os.getpid())
 8     print("子进程的父进程的进程号////////",os.getppid())       # 和主进程的进程号一样
 9 
10 def func2():
11     print("执行func2函数")
12 
13 
14 
15 a = "123456"
16 if __name__ == '__main__':
17     # --------> 在windows下必须要写的, 在创建子进程时, 系统会把当前模块内的所有代码复制一份到子进程中去,
18     # 加上 if __name__ == '__main__', 子进程运行时, __name__在子进程中为"__mp_main__", 不等于"__main__", 不会被执行. 
19 
20 
21 
22     p = Process(target=func1,args=(563,))     # 创建一个进程对象, args参数必须是一个元组的形式
23     p.start()       # 子进程执行start方法,并不是调用子进程, 而是告诉操作系统, 子进程创建好了, 可以让cpu去调用子进程了
24 
25     print("主进程的进程号+++++",os.getpid())
26     print("执行到最后了")
27 
28 
29 
30 
31     print(a+"主进程",__name__)    # 放在  if __name__ == '__main__' 中, 只能执行一次
32 print(a+"子进程",__name__)   # 会被执行两次

继承Process类, 以类的方式创建进程.

1 from multiprocessing import Process
 2 
 3 class MyProcess(Process):
 4 
 5     def __init__(self,m):       # 想要传参必须先继承父类的__init__方法, 然后再封装参数在对象中.
 6         super().__init__()
 7         self.m = m
 8 
 9     def run(self):          # 方法名一定是run(), 否则无意义.
10         print("执行run方法")
11         print(self.m)
12 
13 
14 
15 if __name__ == '__main__':
16 
17     p = MyProcess(360)       # 实例化自己定义的进程类
18     p.start()

参数介绍：   1 group参数未使用，值始终为None

　　　　　　2 target表示调用对象，即子进程要执行的任务

　　　　　　3 name为子进程的名称

 

　　　　　　4 args表示调用对象的位置参数元组，args=(1,2,'egon',)

　　　　　　5 kwargs表示调用对象的字典,kwargs={'name':'egon','age':18}

7、几种方法

　　p.terminate() : 强制终止进程

　　p.is_alive() : 如果p还在运行,就返回True

　　p.join() : 等待子进程结束后主进程再结束. 

　　os.getpid() : 获取该进程的进程号

　　os.getppid() : 获取该进程父进程的进程号

　　p.pid: p进程的进程号

　　p.name: p进程的名字

1 import time
 2 from multiprocessing import Process
 3 
 4 class MyProcess(Process):
 5 
 6     def __init__(self,m):       # 想要传参必须先继承父类的__init__方法, 然后再封装参数在对象中.
 7         super().__init__()
 8         self.m = m
 9 
10     def run(self):          # 方法名一定是run(), 否则无意义.
11         print("执行run方法")
12         print(self.m)
13         time.sleep(5)
14         print("看看terminate好使不")
15 
16 
17 
18 if __name__ == '__main__':
19 
20     p = MyProcess(360)       # 实例化自己定义的进程类
21     p.start()
22 
23     p.terminate()       # 关闭进程,不会立即关闭,有个等着操作系统去关闭这个进程的时间,所以is_alive立刻查看的结果可能还是存活，但是稍微等一会，就被关掉了
24     print(p.is_alive())       # True
25     time.sleep(0.1)
26     print(p.is_alive())         # False

8、进程之间的数据是隔离的, 一般情况下不同进程间的数据是相互访问不到的.

 

1 from multiprocessing import Process
 2 
 3 numb = 100
 4 class MyProcess(Process):
 5 
 6     def run(self):
 7         global numb
 8         numb += 100
 9         print("子进程的numb: ",numb)            # numb都是200, 异步,每个子进程都开始抢占cpu资源
10 
11 
12 
13 
14 if __name__ == '__main__':
15 
16     p_lst = []
17     for i in range(10):
18         p = MyProcess()
19         p.start()
20         p_lst.append(p)         # 创建10个进程并加进列表里
21     for p in p_lst:
22         p.join()         # 等所有的进程都跑完了再走主进程
23 
24     print(numb)             # 还是100, 说明创建的10个子进程都访问不到主进程里的numb, 空间隔离说法成立. 

9、僵尸进程: 一个子进程退出, 那么子进程的进程描述符仍然保存在系统中。这种进程称之为僵死进程

　  孤儿进程：一个父进程退出，而它的一个或多个子进程还在运行，那么那些子进程将成为孤儿进程。孤儿进程将被init进程(进程号为1)所收养，并由init进程对它们完成状态收集工作。

 　　(了解ok)