PYTHON2.day05

1.poll方法实现IO多路复用
   p = poll()
   p.register()
   p.unregister()
   p.poll()
  
2.epoll方法实现IO多路复用
   * 效率更高
   * 触发方式更多
   * 可以监控的更多IO
  
3.struct模块
   功能：python数据转换为bytes发送
        
Struct(fmt)生成数据格式对象
pack()  将数据打包转换为bytes
unpack()  将bytes数据解析

4.本地套接字
    用于本地两个进程之间进行数据通信
   
5.多任务编程
6.进程(process)
  
*****************************************************************************************
一.基于fork的多进程编程
    1.进程的运行特征
      【1】进程可以使用计算机的多核资源
      【2】进程是计算机分配资源的最小单位
      【3】进程之间互不影响，各自独立
      【4】每个进程拥有独立的空间，各自使用自己的空间
    2.fork 使用
      pid = os.fork()
      功能：创建新的进程
      没有参数
      返回值：整数 ，如果创建进程失败，返回负数
                           如果成功，则在原有进程中返回新进程的PID，在新进程中返回0
                    
      注意：*子进程会复制父进程的全部内存空间。从fork下一句开始执行
            * 父子进程各自独立运行，运行顺序不一定，进程执行不同的内容几乎是固定搭配
            *父子进程有各自特征比如
            *父进程fork之前开辟的空间，子进程同样拥有，父子进程对各自空间的操作，
             不会相互影响
       

import os
from time import sleep

pid = os.fork()

if pid < 0:
    print("Creat pricess failed")
elif pid == 0:
    sleep(2)
    print("The new process")
else:
    sleep(3)
    print("The old process")

print("fork test over")

    

eg2:

eg3":

import os
from time import sleep

print("******************")
a= 1


pid = os.fork()

if pid < 0:
    print("Creat process failed")
elif pid == 0:
    print("Child process")
    print("a=%d"%a)
    a = 10000
else:
    # sleep(1)
    print("Parent proess")
    print("a:",a)

print("all a=%d"%a)

import os
from time import sleep

print("******************")
a= 1


pid = os.fork()

if pid < 0:
    print("Creat process failed")
elif pid == 0:
    print("Child process")
    print("a=%d"%a)
    a = 10000
else:
    sleep(1)
    print("Parent proess")
    print("a:",a)

print("all a=%d"%a)

父进程sleep(1)，子进程在先

二.进程相关函数
     1.os.getpid()
       功能：获取一个进程的PID
       返回值：返回当前进程的PID

import os
from time import sleep

pid = os.fork()

if pid <0:
    print("Error")
elif pid == 0:
    print("Child PID:",os.getpid())
else:
    print("Parent PID:",os.getpid())

     2.os.getppid()
       功能：获取父进程的PID号
       返回值：返回父进程PID   

import os
from time import sleep

pid = os.fork()

if pid <0:
    print("Error")
elif pid == 0:
    print("Child PID:",os.getpid())
    print("GET parent pid:",os.getppid())#在子进程中获取父进程pid

else:
    print("Parent PID:",os.getpid())
    print("Det child pid",pid)#在父进程中获取子进程pid

           
     3.os._exit(status)
       功能：结束一个进程
       参数：标书进程的终止状态

import os

os._exit(0)#进程退出

print("Process exit")

     4.sys.exit([status])   默认0
       功能：进程退出
       参数：整数   退出状态
             字符串 表示退出时打印内容
  

import os,sys


sys.exit("退出进程")

print("Process exit")

   
    
三.孤儿和僵尸
     1.孤儿进程：父进程先于子进程退出此时子进程成为孤儿进程
        * 孤儿进程会被系统进程收养，此时系统进程就会成为该进程新的父进程，
          孤儿进程退出该进程会自动处理

    2.僵尸进程：子进程先于父进程退出，父进程没有处理子进程的退出状态，此时子进程就会成为僵尸进程
        * 僵尸进程虽然结束但是会存留部分PCB在内存，大量僵尸进程会占用内存资源
     3.如何避免僵尸进程产生
       [1]:使用wait函数处理子进程退出
           pid，status = os.wait()
           功能：在父进程中阻塞等待处理子进程退出
           返回值：pid 退出的子进程的PID
                   status 子进程退出状态
           pid,status = os.Waitpid(pid,option)
           功能：在父进程中处理进程的进出状态I
           参数：pid -l 表示等待任意子进程退出
                      >0表示指定的子进程退出
                 option  0 表示阻塞等待
                         WHOHANG  表示非阻塞
           返回值：pid 退出的子进程的PID
                   status 子进程退出状态
      [2]创建二级子进程处理僵尸
           1.父进程创建爱你子进程等待回收子进程
           2.子进程创建二级子进程然后退出
           3.二级子进程成为孤儿，和原来的父进程一同执行事件
      [3]通过信号处理子进程退出
          原理：子进程退出时会发送信号给父进程，如果父进程忽略了子进程的信号，
                系统就会自动处理子进程退出
          方法：
               使用signal模块在父进程创建前写下如下语句
              
              import signal
               signal.signal(signal.SIGCHLD,signal.SIG_ING)
          优点：*非阻塞不会影响父进程运行
                *使用该方法父进程可以脱离所有子进程退出
 

import os
from time import sleep

pid = os.fork()

if pid ==0:
    print("Child PID:",os.getpid())
    os._exit(0)
else:
    print("Parent process,...")
    while True:
        pass

 

import os
from time import sleep

pid = os.fork()

if pid <0:
    print("Error")
elif pid == 0:
    sleep(3)
    print("Child %d process exit"%os.getpid())
    os._exit(2)   #2*256 = status: 512

else:
    pid,status = os.wait()
    print("pid:",pid)
#print("status:",status)
    print("status:",os.WEXITSTATUS(status))
    while True:
        pass

 

import os
from time import sleep

print("******************")
a= 1


pid = os.fork()

if pid < 0:
    print("Creat process failed")
elif pid == 0:
    print("Child process")
    print("a=%d"%a)
    a = 10000
else:
    sleep(1)
    print("Parent proess")
    print("a:",a)

print("all a=%d"%a)

 

import os
from time import sleep

pid = os.fork()

if pid <0:
    print("Error")
elif pid == 0:
    sleep(3)
    print("Child %d process exit"%os.getpid())
    os._exit(2)   #2*256 = status: 512
else:
    #非阻塞等待
    while True:
        p,status = os.waitpid(-1,os.WNOHANG)
        if p !=0:
            break
        sleep(2)
        sleep(1)
        print("做了其他事情")
    while True:
        print("完成父进程的其他事情")
        sleep(2)

        

#创建二级子进程处理僵尸
import os
from time import sleep

def f1():
    sleep(3)
    print("元宵．．．")

def f2():
    sleep(4)
    print("处理南北甜咸之争．．．")

pid = os.fork()

if pid <0:
    print("Error")
elif pid ==0:
    p = os.fork()#创建二级子进程
    if p ==0:
        f2()#二级子进程做另一件事
    else:
        os._exit(0)
else:
    os.wait()#等待子进程退出
    f1()

import signal
import os
#处理子进程退出
signal.signal(signal.SIGCHLD,signal.SIG_IGN)
pid = os.fork()
if pid < 0:
    print("Error")
elif pid ==0:
    print("Child PID:",os.getpid())
else:
    pass
    while True:
        pass

群聊聊天室

功能： 类似qq微信群聊

1. 进群需要输入姓名，姓名不能重复
2. 进入聊天室会向其他人发送通知 
     xxx 进入了聊天室
3. 某人发消息群里其他人能够收到
     xxx说：xxxxxxxxxxxx
4. 某人退出聊天室也会向其他人发通知
     xxx 退出了聊天室
5. 管理员可以发送管理员消息，此时群里所有人都能收到
     管理员说：xxxxxxxx
（服务器可以向所有的用户发送）

1. 确定技术模型
    -使用字典保存用户信息{name:ip}
    - 消息发送:客户端--》服务端--》其他客户端
    - 套接字:udp套接字
    * 存储用户:字典或者列表
    - 消息收发随意:使用两个(多)进程分别处理消息收发
     

2. 注意事项
    * 设计封装方法                       将每个功能封装为函数
    * 写一个模块测试一个函数             实现一个功能，测试一个功能
    * 注释的编写添加                    
    * 流程                               搭建网络连接，逐个功能实现                              
          
          
具体实现功能

   1. 搭建网络连接
        服务端 ： 创建UDP套接字，绑定地址，创建多进程

       客户端 ： 创建UDP套接字，创建多0进程

   2. 用户登录
        服务端 ： *  接收姓名
                  * 判断姓名是否存在
                  * 根据判断结果回复客户端
                  * 不允许登录则功能结束
                  * 允许登录将用户则加入数据结构
                  * 将用户登录提示发送给其他人

        客户端 ： * 输入姓名
                  * 将姓名发送给服务器
                  * 接收服务器反馈 ，如果不允许登录则重新输入，允许则进入聊天
                  * 创建新的进程，用于消息收发

    3. 聊天
     服务端：     * 接收消息，判断请求类型
                  * 将消息转发给其用户

    客户端：     * 循环发送消息
                  * 循环接收消息

   4. 用户退出
     服务端 ： * 收到q表示客户端退出
               * 将用户从user移除
           * 告知其他人xxx退出，给该用户发送退   出指令

    客户端 ： * 输入q表示退出
               * 将退出信息发送给服务器
           * 发送进程退出
           * 接收进程接收到服务器指令退出

   5. 管理员消息

#coding=utf-8
'''
Chatroom
env:python3.5
exc:socket and fork
'''
from socket import *
import os,sys

#用于存储用户{name:addr}
user ={}

#处理登录
def do_login(s,name,addr):
    #判断姓名是否存在
    if name in user:
        s.sendto("该用户已存在".encode(),addr)
        return
    s.sendto(b'OK',addr)

    #先通知其他人
    msg = "欢迎%s 进入聊天室"%name
    for i in user:
        s.sendto(msg.encode(),user[i])#user[i]发送，通过键取值
    #将用户插入user
    user[name] = addr


def do_chat(s,name,text):
    msg ="%s : %s"%(name,text)#格式
    #循环发送给所有人，除了自己
    for i in user:
        if i != name:
            s.sendto(msg.encode(),user[i])#接受UDP消息,user[i]发送，通过键取值



def do_requests(s):
    while True:
        data,addr = s.recvfrom(1024)#接收UDP消息
        #解析请求
        msgList = data.decode().split(' ')#＊spilt('.')方法将指定的分隔符进行拆分，拆分将会组成一个字符串的数组并返回
        #区分请求类型
        if msgList[0]=='L':
            do_login(s,msgList[1],addr)
        elif msgList[0] =='C':
            #重新组织消息内容
            text = ' '.join(msgList[2:])
            do_chat(s,msgList[1],text)
        elif msgList[0] == 'Q':
            do_quit(s,user,msgList[1])

def do_quit(s,user,name):
    msg = "
%s 退出了聊天室"%name
    for i in user:
        if i == name:
            s.sendto(b'quit',user[i])
        else:
            s.sendto(msg.encode(),user[i])
    #删除该用户
    del user[name]

#创建网络连接
def main():
    ADDR = ('0.0.0.0',8888)
    #创建套接字
    s = socket(AF_INET,SOCK_DGRAM)#创建数据报套接字
    s.bind(ADDR)#绑定地址

    #处理各种客户端请求
    do_requests(s)

if __name__=="__main__":
    main()

from socket import *
import os,sys

#服务区的地址
ADDR = ('172.40.71.149',8888)

#发送消息
def send_msg(s,name):#发消息
    #输入q表示退出聊天室
    while True:
        text = input("发言:")
        if text =="q":
            msg = 'Q ' + name
            s.sendto(msg.encode(),ADDR)
            sys.exit("退出聊天室")
        msg = "C %s %s"%(name,text)#C
        s.sendto(msg.encode(),ADDR)


def recv_msg(s):#收消息
    while True:
        data,addr = s.recvfrom(2048)
        #服务器发来quit表示要退出
        if data.decode()=="quit":
            sys.exit(0)
        print(data.decode(),"
发言：",end="")

#创建网络连接
def main():
    s = socket(AF_INET,SOCK_DGRAM)
    while True:
        name = input("请输入姓名：")
        msg = "L "+name
        s.sendto(msg.encode(),ADDR)#发送请求给服务端
        #等待回应
        data,addr = s.recvfrom(1024)#消息收发
        if data.decode() =="OK":
            print("您已经进入聊天室")
            break
        else:
            print(data.decode())#打印不允许的原因

    #创建新的进程，用以消息收发的随意性
    pid = os.fork()#创建新的进程
    if pid < 0:
        sys.exit("error创建进程失败!!")
    elif pid == 0:
        send_msg(s,name)#发送消息
    else:
        recv_msg(s)#接受消息


if __name__=="__main__":
    main()

作业： 1. 完成退出功能,解决格式问题
           聊天过程中输入quit表示退出
        2. 整理fork创建进程内容
        3. 用fork创建父子进程，同时复制一个文件，各复制一半到一个新的文件中