学习笔记☞python3☞网络编程（四）☞【本地套接字，多进程，进程状态，优先级，孤儿进程，僵尸进程及处理】

1、本地套接字

    1、Linux下文件类型

        b(块设备文件)            c(字符设备文件 显示器，键盘等)
        d(文件夹)                -(普通文件 压缩包，音视频，文本)
        l(连接文件)              s(套接字文件)
        p(管道文件)

    2、意义：

        在Linux和Unix操作系统下，提供本地进程间通信的一种方式

2、本地套接字创建流程(服务端)

    1、创建套接字文件

    2、绑定套接字文件
    3、监听
    4、接收连接

    5、消息收发

 

    *_*cookie*_*

       1、 os.unlink()
            功能：
                删除某个文件
            参数：
                文件路径
        2、os.path.exists()
            功能：
                判断一个文件是否存在，存在返回True，不存在返回False
            参数：
                一个文件路径

3、多任务编程

    通过应用程序利用多个计算机核心达到多任务同时执行的目的，
    以此来提升程序的执行效率

4、多进程

    1、进程的定义：

        程序在计算机中一次执行的过程

    2、程序与进程的区别

        1、程序：是一个静态的描述，不占有计算机资源

        2、进程(process)：是一个动态的过程吗，占有CPU内存的计算机资源，有一定的声明周期

        *3、同一个程序，每次运行都是不同的进程，因为分配的计算机资源不同

    3、进程的创建流程

        用户控件运行程序发起进程创建申请
                    |
                   \|/
        调用操作系统内核创建进程
                    |
                   \|/
        分配计算机资源,确定进程状态
                    |
                   \|/
        将新的进程提供给用户使用

    4、多个进程，如何占用CPU

        1、统一内核，统一时刻只能运行统一任务
        2、多个进程对内核资源进行争夺，操作系统决定哪个系统占有计算机核心
        3、占有计算机核心的进程我们称为占有CPU的时间片

    5、进程有哪些信息，如何保存

        1、PCB(进程控制块)

            Linux和Unix系统中进程创建后，会在内存开辟一块空间存放进程的相关信息，称为PCB

        2、信息：

            1、查看进程信息：

                ps -aux

            2、信息

                用户  PID     占有内存    优先级 等

            3、PID：

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

    6、进程特征

        1、进程是操作系统资源分配的最小单位
        2、每个进程单独占有4G虚拟内存
        3、进程之间相互独立，运行不受影响

    7、进程的状态

        1、三态

            就绪态：进程具备运行条件，等待系统分配处理器运行
            运行态：进程占有CPU处于运行的状态
            等待态：又称为阻塞态，睡眠态，指进程暂时不具备运行的条件，需要阻塞等待(sleep accept ……)

        2、五态

            新建态：创建一个进程，获取资源，直接表现为运行一个程序，或者在程序中创建新的进程
             +
            三态
             +
            终止态：进程执行结束，资源回收过程

        3、Linux进程状态表示含义

            D   等待态     (不可中断等待)
            S   等待态     (可中断等待)
            T   等待态     (暂停)
            R   运行态
            Z   僵尸态
            +   前台进程    (不带+即为后台进程)
            <   高优先级
            N   低优先级
            l   有进程连接
            s   会话组

    8、进程优先级

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

        1、查看进程优先级

            top ：动态查看当前运行的进程的状态 ，q 退出   < > 翻页

        2、Linux中优先级范围

            -20~19
            数越小，优先级越高
            用户程序默认优先级为0
 

        3、nice : 已指定的优先级运行进程

            nice -9 python3 while.py        以9的优先级运行此程序
        4、renice:改变某个进程的优先级
            renice 2 PID

    9、父子进程

        在系统中除了初始化进程其他进程都有一个父进程，可能有多个子进程
 

        1、查看进程树：

            pstree
 

        2、查看父进程id：

            ps -ajx
 

5、需求：编写一个程序可以同时做多件事情

    方案：使用两个进程分别完成预定事件

    1、os.fork()

        功能：
            创建一个新的进程
        参数：无
        返回值：
            1、失败返回一个负数
            2、成功返回 0    在子进程中fork的返回值
                       >0    的正整数(新的进程的PID号)在父进程中的返回值
        示例：

# os为系统相关模块，不同操作系统使用情况不同
import os

print('准备创建进程')
a = 1  # 子进程中也有变量a
pid = os.fork()
if pid < 0:
	print('创建进程失败')
elif pid == 0:
	print('创建了一个新的进程')
else:
	print('这是原有的进程')
print('进程执行完毕')            

    总结：
        1、父进程中fork之前的内容子进程同样会复制，但父子进程空间独立，fork之后的修改不会影响到对方
        2、父子进程在执行上互不影响，谁先执行，谁先执行完不确定
        3、子进程虽然复制父进程的空间，但是有自己的特性，比如自己的PID，进程PCB，进程栈空间等。

    2、进程相关函数

        1、获取PID号

            1、os.getpid()

                功能：
                    获取当前进程的PID号
                返回值：
                    当前进程PID
 

            2、os.getppid()

                功能：
                    获取当前进程父进程的PID号
                返回值：
                    父进程的PID
        示例：

import os
import time

pid = os.fork()
if pid < 0:
	print('Create proces failed')
elif pid == 0:
	print('Child proces')
	print('getpid()',os.getpid())#子进程自己获取自己的pid
	print('getppid()',os.getppid())
	print('==========================')
else:
	time.sleep(1)
	print('Parent process')
	print('pid()',pid)#父进程fork返回值就是子进程的pid
	print('getpid()',os.getpid())           

    2、进程的退出

        1、os._exit(status)

            功能：
                结束一个进程
            参数：
                表示进程的结束状态，是一个整数
                0 ： 表示进程正常退出
                非0：表示非正常退出
            示例：

import os

os._exit(0)
print('Process over')

        2、sys.exit([status])

            功能：
                结束一个进程，抛出异常
            参数：
                传入一个正整数表示结束状态
                传入字符串表示结束打印
            示例：

import sys


try:
	sys.exit(1)
except SystemExit as e:
	print(e)
print('Process over')
'''
运行结果
1
Process over
'''                

6、孤儿进程

    父进程先于子进程退出，此时子进程变为孤儿进程
    *孤儿进程会被系统指定的进程所''收养''，既该进程成为孤儿进程新的父进程
    在孤儿进程退出时，''继父''会进行处理不会成为僵尸进程
    示例：

import os
import time

pid = os.fork()
if pid < 0:
	print('Create process failed')
elif pid == 0:
	# 父进程已退出，打印的是新的父进程的PID
	time.sleep(1)
	print('My parent PID:', os.getppid())
else:
	print('Parent pid:', os.getpid())

7、僵尸进程

    子进程先于父进程退出，但是父进程没有处理子进程的退出状况，子进程就会变成僵尸进程
    *僵尸进程会滞留PCB的部分信息在内存中，大量的僵尸进程会消耗系统资源，所以应该避免僵尸进程的产生。
 

    1、如何避免僵尸进程的产生

        1、让父进程先退出 (不好控制)

        2、让父进程处理子进程的退出

            1、使用wait 或者 waitpid 函数

                os.wait()
                    功能：
                        等待子进程的退出进行处理，阻塞函数
                    参数：
                        无
                    返回值：
                        一个二元元组，第一个值为退出的子进程pid，第二个值为子进程退出状态
                    示例：

import os
import sys
import time

pid = os.fork()
if pid < 0:
	print('Create process failed')
elif pid == 0:
	print('Child process')
	time.sleep(2)
	sys.exit(3)
else:
	p, status = os.wait()
	print(p, status)
	while True:
		pass

            2、使用信号处理

        3、创建二级子进程