PYTHON2.day06

前情回顾

1. 进程相关函数
    os.getpid()  获取当前进程的PID
    os.getppid() 获取父进程PID
    os._exit()  退出进程
    sys.exit()  退出进程

2. 孤儿进程和僵尸进程
   
    如何避免僵尸进程
        【1】 使用wait，waitpid处理僵尸进程
        【2】 创建二级子进程处理僵尸进程

3. 聊天室程序
   
    确定需求--> 基本的技术分析--》整体设计--》功能分析--》代码实现--》代码测试完善
**********************************************************************************************
一.群聊聊天室
    1.退出功能
      【1】服务端
           * 接收消息确定消息类型
           * 将用户从字典移除
           * 将退出消息发送给其他人
           * 给该用户发送特殊标志
      【2】客户端
           * 输入quit退出
           * 将退出请求发送给服务器然后结束进程
           * recv接收服务器信息后退出         
     2.管理员消息

二.multiprocessing 模块创建进程
    1.流程特点   
         【1】将需要子进程执行的事件封装为函数
         【2】通过模块的Process类创建进程对象,关联函数
         【3】通过进程对象设置进程信息及属性
         【4】通过进程对象调用Start启动进程
         【5】通过进程对象调用join回收进程
        
     2.基本接口使用
       【1】Process()
            功能：创建进程对象
            参数：target(绑定要执行的目标函数)(必选)
                  args 元组，用于给target函数位置传参
                  kwargs 字典，给target函数键值传参
     

import multiprocessing as mp
from time import sleep

#编写进程函数
def fun():
    sleep(3)
    print("子进程")

#创建进程对象
p= mp.Process(target=fun)
 #启动进程
p.start()

sleep(2)
print("父进程")
 #回收进程
p.join()

import multiprocessing as mp
from time import sleep

a = 1

#编写进程函数
def fun():
    sleep(3)
    global a
    print("a=",a)
    a = 10000
    print("子进程")

#创建进程对象
p= mp.Process(target=fun)
 #启动进程
p.start()

sleep(2)
print("父进程")
 #回收进程（处理僵尸进程）
p.join()

print("---------------")
print("parent a=",a)

from multiprocessing import Process
from time import sleep
import os

def th1():
    sleep(3)
    print("茶饭")
    print(os.getppid(),'----',os.getpid())
def th2():
    sleep(2)
    print("睡觉")
    print(os.getppid(),'----',os.getpid())
def th3():
    sleep(4)
    print("xxx")
    print(os.getppid(),'----',os.getpid())

things = [th1,th2,th3]
processes = []
for th in things:
    p = Process(target = th)
    processes.append(p)#用列表保存进程对象
    p.start()

for i in processes:
    i.join()

from multiprocessing import Process
from time import sleep

#带参数的进程函数
def Worker(sec,name):
    for i in range(3):
        sleep(sec)
        print("I'm %s"%name)
        print("I'm working...")
#3# p = Process(target = Worker,args = (2,"Levt"))
#4#p = Process(target = Worker,kwargs={'name':'Tom','sec':2})#两种方式
p = Process(target = Worker,args=(2,),kwargs={'name':'Tom'})#3种方式
p.start()
p.join()

from multiprocessing import Process
from time import sleep

#带参数的进程函数
def Worker(sec,name):
    for i in range(3):
        sleep(sec)
        print("I'm %s"%name)
        print("I'm working...")
#3# p = Process(target = Worker,args = (2,"Levt"))
#4#p = Process(target = Worker,kwargs={'name':'Tom','sec':2})#两种方式
p = Process(target = Worker,args=(2,),kwargs={'name':'Tom'})#3种方式
p.start()
p.join()

from multiprocessing import Process
from time import sleep,ctime

def tm():
    for i in range(3):
        sleep(2)
        print(ctime())

# p = Process(target = tm)
p = Process(target = tm,name = "tedu")

p.daemon = True#主进程退出之后子进程接着退出，p.join()二选一

p.start()
print("Process name",p.name)#进程名称
print("Process pid",p.pid)#对应子进程的PID
print("alive:",p.is_alive())#查看子进程是否在声明周期


p.join(2)#如果daemon设置成True通常就不使用join
print("------------------------")

       【2】p.start()
            功能：启动进程
            * 启动进程此时target绑定函数开始执行,该函数作为子进程执行内容，
              此时进程真正被创建
       【3】p.join([timeout])
             功能：阻塞等待回收进程
             参数：超时时间
        注意：* multiprocessing创建进程同样是子进程复制父进程空间代码段,父子进程运行互不影响
              * 子进程只运行target绑定的函数部分，其余均是父进程的执行内容
              * 父进程执行内容
                 multiprocessing中父进程往往只用来创建子进程回收子进程，
                 具体事情由子进程完成            
              * multiprocessing 创建的子进程中无法使用标准输入
                
     3.进程对象属性
         p.name    进程名称
        p.pid     对应子进程的PID
         p.is_alive()   查看子进程是否在声明周期
         p.daemon  设置父子进程的退出关系
           *如果设置为True则子进程会随父进程的退出而结束
           *要求必须在start()前设置
           *如果daemon设置成True通常就不使用join   
          
     4.自定义进程类
        编写流程：
         【1】定义进程类继承Process
         【2】编写__init__方法,使用super重新加载父类的__init__方法
         【3】重写Process中的run方法
        使用方法：
           【1】使用自定义类，实例化对象，
           【2】通过对象调用start创建进程，自动运行run方法
           【3】实例化对象调用jion()回收子进程
          

from multiprocessing import Process
import time

#自定义进程类
class ClockProcess(Process):
    def __init__(self,value):
        self.value = value
        super().__init__()

    #重写run 方法
    def run(self):
        for i in range(5):
            print("The time is %s"%time.ctime())
            time.sleep(self.value)

#创建进程对象
p = ClockProcess(2)
#启动新的进程
p.start()
p.join()

三.进程池技术
     1.必要性：
       [1]:进程的创建和销毁过程消耗的资源较多
       [2]:当任务众多，每个任务在很短时间内完成时，需要频繁创建和销毁进程，此时对计算机压力较大
       [3]:进程池技术很好的解决了以上问题
     2.原理：
         创建一定数量的进程类处理事件，事件处理完进程不退出而是继续处理其他事件，
         直到所有事件全部处理完毕同一销毁。进价进程重新利用，降低资源消耗。
     3.实现
      【1】创建进程对象，放入适当的进程
            from multiprocessing import pool

            Pool（process）
             功能：创建进程池对象
             参数：指定进程数量，默认根据系统自动判断
       【2】事件加入进程池队列执行
            pool.apply_async(func,args,kwds)
            功能：使用进程池执行func事件
            参数：func 事件函数
                  args 元组 给func按位置传参
                  kwds 字典 给func按键值传参
            返回值：返回函数事件对象
           
       【3】关闭进程池
             pool.close()
       【4】回收进程池中的进程
            pool.join()
           
       【5】通过map添加进程池事件
            pool.map(func,iter)
            map执行自动调用func,参数为：执行iter的可迭代     
            功能：将要做的事件加入进程池
            参数：func 事件函数
                  iter 迭代对象，将迭代值传给func
            返回值：得到函数返回值列表
           

from multiprocessing import Pool
from time import sleep,ctime

#进程事件
def worker(msg):
    sleep(2)
    print(msg)#参数不同
    return ctime()
#创建进程池
pool  = Pool()
# pool  = Pool(4)#同事启动四个进程

result = []
#向进程池添加事件
for i in range(10):
    msg = "hello %d"%i
    r =pool.apply_async(func=worker,args=(msg,))#传给形参-->(msg)
    result.append(r)#存储事件对象

#关闭进程池
pool.close()
#回收进程池
pool.join()
for i in result:
    print(i.get())#通过对象get()可以获取事件函数返回值

           
  

from multiprocessing import Pool
import time

def fun(n):
    time.sleep(1)
    return n * n
pool = Pool()
#使用map将事件放入进程池
r = pool.map(fun,[1,2,3,4,5])
pool.close()
pool.join()

print("结果",r)
#3s

        
四.进程间通信(IPC)
     1.必要性：进程间空间独立,资源不共享,
                   此时在需要进程间数据传输时就需要特定的手段进行数据通信
              
     2.进程间通信方法：
         管道      消息队列      共享内存     信号     信号量     套接字
        
     3.管道通信(Pipe)
       [1]通信原理：在内存中开辟管道空间，生成管道操作对象，
                    多个进程使用同一个管道对象进行读写即可实现通信
       [2]实现方法：
                   from multiprocessing import Pipe
                   
                    fd1,fd2 = Pipe(duplex = True)
                    功能：创建管道
                    参数：默认True表示双向管道（都可读可写）
                          如果为False 表示单向管道
                    返回值：表示管道两端从的读写对象
                            如果是双向管道均可读写
                            如果是单向管道fd1只读  fd2只写
                     fd.recv()
                     功能：从管道获取内容
                     返回值：获取到的数据
                     fd.send(data)
                     功能：向管道写入内容
                     参数：要写入的数据
     

from multiprocessing import Process,Pipe
import os,time

#创建管道对象
fd1,fd2 = Pipe()

def fun(name):
    time.sleep(3)
    #向管道写入内容
    fd1.send(name)


jobs =[]
for i in range(5):
    p = Process(target = fun,args = (i,))
    jobs.append(p)
    p.start()


for i in range(5):
    #读取管道内容
    data = fd2.recv()
    print(data)


for i in jobs:
    i.join()

from multiprocessing import Process,Pipe
import os,time


fd1,fd2 = Pipe()

def fun(name):
    time.sleep(3)
    #向管道写入内容
    fd1.send({name:os.getpid()})

jobs =[]
for i in range(5):
    p = Process(target = fun,args = (i,))
    jobs.append(p)
    p.start()


for i in range(5):
    #读取管道内容
    data = fd2.recv()
    print(data)


for i in jobs:
    i.join()

  

from multiprocessing import Process,Pipe
import os,time


fd1,fd2 = Pipe(False)

def fun(name):
    time.sleep(3)
    #向管道写入内容
    fd1.send({name:os.getpid()})

jobs =[]
for i in range(5):
    p = Process(target = fun,args = (i,))
    jobs.append(p)
    p.start()


for i in range(5):
    #读取管道内容
    data = fd2.recv()
    print(data)


for i in jobs:
    i.join()

           
     4.消息队列
       【1】通信原理：在内存中建立通信模型，进程通过队列将消息存入，
                      或者从队列取出完成进程间通信   
       【2】实现方法：
                     from multiprocessing import Queue
                    
                     q = Queue(maxsize=0)
                     功能:创建队列队列
                     参数：最多存放的消息个数
                     返回值：队列对象
                    
                     q.put(data,[block,timeout])
                     功能：向队列存入消息
                     参数：data 要存入的内容
                           block  设置是否阻塞 ，默认True阻塞，False为非阻塞
                           timeout 超时检测
                     q.get([block,timeout])
                     功能：从队列取出消息
                     参数：data 要存入的内容
                           block  设置是否阻塞 ，默认True阻塞，False为非阻塞
                           timeout 超时检测
                     返回值：返回获取到的内容
                    
                     q.full()判断队列是否为满
                     q.empty()判断队列是否为空
                     q.qsize()获取队列的消息个数
                     q.close()关闭队列
                    
    

from multiprocessing import Queue,Process
from time import sleep

#创建消息对列
q = Queue(3)
#写
def fun1():
    for i in range(3):
        sleep(1)
        q.put((1,3))
#读
def fun2():
    for i in range(4):
        a,b = q.get(timeout=3)
        print("sum=",a+b)

p1 = Process(target=fun1)
p2 = Process(target=fun2)
p1.start()
p2.start()
p1.join()
p2.join()

               
作业：1.父子进程共同复制一个文件，分别复制文件上半部分和下半部分到另一新文件中。
       2.类的设计和函数传参                   
      

import os

filename = 'xl.txt'

#获取文件大小
size = os.path.getsize(filename)

# 父子进程共用一个文件对象偏移量会相互影响
# f = open(filename,'rb')

pid = os.fork()
if pid < 0:
    print("Error")
elif pid == 0:
    #复制上半部分
    f = open(filename,'rb')
    fw = open("1",'wb')
    n = size // 2
    while True:
        if n < 1024:
            data = f.read(n)
            fw.write(data)
            break
        data = f.read(1024)
        fw.write(data)
        n -= 1024
    f.close()
    fw.close()
else:
    #复制下半部分
    f = open(filename,'rb')
    fw = open("2",'wb')
    f.seek(size//2,0)
    while True:
        data = f.read(1024)
        if not data:
            break
        fw.write(data)
    f.close()
    fw.close()