Python之路PythonThread，第一篇，进程1

python3 进程1

多任务编程： 可以有效的利用计算机资源，同时执行多个任务，

进程：进程就是程序在计算机中一次执行的结果；

进程和程序的区别：

程序是一个静态文件的描述，不占用计算机的系统资源；

进程是一个动态的过程，占有cpu内存等资源，有一定的生命周期；

* 同一个程序的不同执行过程即为不同的进程；

问题1 ，什么决定了进程的创建；

用户通过应用层程序进行进程的创建申请 ----》》

调用操作系统接口进行程序创建--》》

告知系统内核创建新的进程提供给应用层使用

问题2，进程如何占用CPU

1，同一个内核同一时刻只能运行一个进程

2， 多个进程对内核资源进行抢占，由操作系统内核进行分配

3，哪个进程占有计算机内核我们称之为该进程占有CPU的时间片；

问题3， 进程在运行过程中的形态和附带内容；

PCB（进程控制块）：在linux和unix操作系统中，进程创建后会在内存中开辟一块空间存放进程的相关信息，这个空间称之为PCB；

PID ： 在操作系统中进程的唯一标识，是一个大于0的正整数，由系统自动分配

ps -aux 查看进程信息

虚拟内存：每个进程占用4G内存地址空间，这里的内存指虚拟空间；

进程状态：

三态： 就绪态、  运行态 、   等待态

就绪态： 进程具备运行条件，等待系统分派处理器以便运行；

运行态：进程占有cpu处于运行状态

等待态： 又称为阻塞态或睡眠态， 指进程不具备运行条件，正在等待某些条件的达成

五态：  就绪态、  运行态 、   等待态 、  新建态、 终止态

新建态：创建一个进程的过程，直接表现为执行某个程序或在程序中创建新的进程；

终止态：进程执行结束，完成回收的过程；

D   等待态（不可中断）

S    等待态（可中断）

T    等待态（暂停状态）

R  运行态

Z  僵尸态

+   前台进行

N   低优先级的进程

<   高优先级的进程

l     有进程连接

s     会话组

进程的优先级：

优先级往往决定了一个进程的执行权限和占有系统资源的优先程度；

top ： 动态查看系统进程运行的情况；

<   > 进行翻页查找

linux 系统优先级范围 （-20 ~ 19），其中（-20）优先级最高；

用户创建进程默认优先级为0

nice  ： 以指定的优先级运行某个进程；

例： nice  -9  ./xxx.py  #以9为优先级运行程序

sudo  nice  - - 9  ./xxx #以-9为优先级运行程序

renice  n  PID   ： 修改一个正在运行的进程的优先级；

例： renice  8  6277 将6277号进程优先级修改为8

父子进程：在系统中除了初始化进程之外每个进程都是由父进程创建的，每个进程有一个唯一的父进程，可能有多个子进程；

pstree

总结：

1，什么是进程

2，进程和程序的区别

3，进程的几种状态及相互间的转换

4，什么是PCB   PID   CPU时间片

需求：两件不相关事情希望同时来做

方案1： 写两个进程，分别承担不同的事情，各自执行；

分析：1，两个程序比较麻烦； 2，无法确定两个程序应该在什么时间开始运行；

方案2： 写一个程序，在程序中指定位置调用接口来创建新的进程；

实现方法：

通过 os.fork() 函数实现

fork()

功能：创建一个新的进程

参数：无

返回值： < 0   #表示进程创建失败；

==0  #在子进程中fork的返回值为0；

> 0   #在父进程中fork的返回值大于0；

（fork是os模块函数，只能在linux和unix下使用）

测试1： 在父进程中fork之前的内容，子进程同样也会复制； 但是父子进程空间内容的修改不会互相影响；

测试2：父子进程在执行上互不影响，理论上不一定谁先执行；

测试3： 子进程虽然复制父进程的空间，但是也有自己的独特的特性，比如自己的PID，进程控制块，进程栈等。父进程中fork的返回值即为创建的子进程的PID号；

进程相关函数：

os.getpid()

功能： 获取当前进程的PID号；

os.getppid()

功能：获取当前进程父进程的PID号；

 #os 模块提供大量和系统相关的功能函数接口
 #os模块的使用是系统相关的 在不同的系统中
 #可能使用方法不同
 import os 

 print('before create process')
 a = 10

 #创建新的进程
 pid = os.fork()

 if pid < 0:
     print('create process failed')
 elif pid == 0:
     print('This is the new process')
     print(a)
     a = 1000
 else:
     print('This is the parent process')

 print("The process end")
 print(a)

 ##############fork1#
 import os
 import time 

 #创建新的进程
 pid = os.fork()

 if pid < 0:
     print('create process failed')
 elif pid == 0:
     print('pid:',pid)
     while True:
         time.sleep(0.8)
         print('This is the new process')
         #子进程的退出不会影响父进程
         os._exit(0)
 else:
     #父进程中pid为子进程的PID号
     print('parent pid:',pid)
     while True:
         time.sleep(1)
         print('This is the parent process')

 print("The process end")
 ############fork2#
 import time 

 def fun1():
     time.sleep(6)
     print('做完第一件事情')

 def fun2():
     time.sleep(4)
     print('做完第二件事情') 

 # fun1()
 # fun2()
 ###
 import os
 import time
 from test import * 

 #创建新的进程
 pid = os.fork()

 if pid < 0:
     print('create process failed')
 elif pid == 0:
     fun1()
 else:
     fun2()
 #############fork3##

 import os 

 pid = os.fork()

 if pid < 0:
     print('create process failed')
 elif pid == 0:
     print("Child process:")
     print("当前进程的PID:",os.getpid())
     print("当前进程父进程的PID:",os.getppid())
 else:
     print("Parent process:")
     print("pid:",pid)
     print("当前进程的PID号:",os.getpid())

结束一个进程

os._exit(status)

功能：结束一个进程

参数：一个数字表示进程的退出状态，通常0表示正常退出进程其他数字表示非正常退出

sys.exit([status])

功能：结束一个进程，如果处理了抛出的异常则不结束进程

参数：一个数字表示进程的退出状态，通常0表示正常退出进程其他数字表示非正常退出;

还可以是一个字符串， 则在进程退出时会打印这个字符串；

 #####
 #!/usr/bin/python3

 import os
 import sys

 os._exit(0) #结束进程，不执行后面的语句；

 print('process over')
 ~
 ######
 #!/usr/bin/python3

 import os
 import sys

 #os._exit(0)
 sys.exit() #结束进程，不执行后面的语句；

 print('process over')
 ########

 #!/usr/bin/python3

 import os
 import sys

 #os._exit(0)
 #sys.exit()
 try:
     sys.exit('结束了。')  #当它进行处理了异常，则执行下面的语句
 except SystemExit as e:
     print('++++'e)

 print('process over')

 ###结果：
 $ ./exit.py
 ++++ 结束了。
 process over

 import os
 import time 

 #创建新的进程
 pid = os.fork()

 if pid < 0:
     print('create process failed')
 elif pid == 0:
     print('pid:',pid)
     while True:
         time.sleep(0.8)
         print('This is the new process')
         #子进程的退出不会影响父进程
         os._exit(0)
 else:
     #父进程中pid为子进程的PID号
     print('parent pid:',pid)
     while True:
         time.sleep(1)
         print('This is the parent process')

 print("The process end")

僵尸进程：子进程先于父进程退出，父进程没有对子进程的退出做相应的处理，此时子进程就会变为僵尸进程；

影响：进程退出后，仍有部分信息残留在内存中占用空间，大量的僵尸进程会影响系统运行。所以应该尽量避免僵尸进程的产生；

 cat zombie.py
 #!/usr/bin/python3

 import os
 import time

 pid = os.fork()

 if pid < 0:
     print('create new process failed.')
 elif pid == 0:
     print('子进程退出了')
     os._exit(0)
 else:
     time.sleep(1)
     print('Child PID:',pid)
     while True:
         pass
 ##
 python3 zombie.py
 子进程退出了
 Child PID: 3710
 ##
 tarena     3710  0.0  0.0      0     0 pts/2    Z+   21:18   0:00 [python3] <defunct>
 tarena     3711  0.0  0.3  39104  3224 pts/6    R+   21:18   0:00 ps -aux

孤儿进程：父进程先于子进程退出，此时子进程就会变成孤儿进程；

影响：当一个进程变为孤儿进程，系统就会自动的使用一个进程称为孤儿进程的父进程。当孤儿进程退出时，该系统进程会自动回收孤儿，使他不会称为僵尸；所以孤儿进程对系统资源没有什么影响；

 #!/usr/bin/python3

 import os
 import time

 pid = os.fork()

 if pid < 0:
     print('create new process failed.')
 elif pid == 0:
     print('父进程的ＰＩＤ：',os.getppid())
     time.sleep(3)
     print('父进程的PID',os.getppid())
     print('子进程退出了')
     os._exit(0)
 else:
     #time.sleep(1)
     print('Child PID:',pid)
     #while True:
     #    pass
 ###
 Child PID: 3778
 父进程的ＰＩＤ： 3777
 #:~/process$ 父进程的PID 2073
 子进程退出了

处理僵尸进程的方法：

1，让父进程先退出；（缺点：不好控制）

2，父进程处理子进程的退出；（阻塞父进程的运行）

os.wait()

功能：等待子进程退出进行处理；

参数：无

返回值：返回一个包含两个元素的元组，第一个是退出的子进程的PID号，第二个是子进程的退出状态；

（wait是一个阻塞函数，即 进程处于等待态，等待某种条件的达成才会继续运行；）

 import os
 import sys
 from time import sleep

 pid = os.fork()

 if pid < 0:
     print('create process failed.')
 elif pid == 0:
     print('Child process...')
     sleep(2)
     sys.exit(6) #子进程退出(6x256=1536)
 else:
     p,status = os.wait()##wait阻塞等待子进程的退出
     print('pid:',p,'status:',status)
     print('Parent process...')
 ####
 Child process...
 pid: 3838 status: 1536
 Parent process...

os.waitpid(pid，option)

功能：处理子进程的退出使其不会变成僵尸进程；

参数：pid  -1  等待任意子进程退出；

　　    pid > 0 表示等待指定进程号的子进程退出；

　　   option    0   表示阻塞等待

option     WNOHANG  表示非阻塞状态；

返回值 ： 同wait

wait() ====> waitpid(-1,0)

 import os
 import sys
 from time import sleep

 pid = os.fork()

 if pid < 0:
     print('create process failed.')
 elif pid == 0:
     print('Child process...')
     sleep(2)
     sys.exit(6) #子进程退出
 else:
     #waitpid非阻塞等待子进程的退出
     p,status = os.waitpid(-1,os.WNOHANG)
     print('p:',p,'status:',status)
     print(os.WEXITSTATUS(status))
     print('Parent process...')
 ###
 $ python3  waitpid.py
 p: 0 status: 0
 0
 Parent process...
 Child process...

使用open拷贝一个文件，要求将文件拷贝为两份
第一份为前半部分，第二份为后半部分
分别用父子进程拷贝

总结：

1.函数的使用 fork getpid getppid _exit exit wait
waitpid

2. 理解什么是僵尸进程什么是孤儿进程即两者产生的过程

3. 知道僵尸进程的危害和两种处理方法

4. 理解进程的创建流程