python 进程线程 day05

最新推荐文章于 2024-10-30 20:07:18 发布
最新推荐文章于 2024-10-30 20:07:18 发布
阅读量549 收藏 2
点赞数 1
文章标签： python 父子进程 聊天程序 孤儿僵尸进程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42584444/article/details/81557285
版权

2018.8.10

目录

孤儿、僵尸进程

写一个聊天室

multiprocessing 模块创建进程

day05

孤儿、僵尸进程

  • 孤儿进程：当父进程先于子进程退出，此时子进程就会成为孤儿进程。
    孤儿进程会被系统指定进程收养，即系统进程会成为孤儿进程新的父进程，系统进程会自动处理孤儿进程退出状态 
    import os 
from time import sleep 

pid = os.fork()

if pid == 0:
    print("child PID:",os.getppid())
    sleep(2)
    print("parent PID again:",os.getppid())
elif pid > 0:
    sleep(1)
    print("parent process:",os.getpid())

     

  • 僵尸进程：子进程先于父进程退出，父进程没有处理子进程的退出状态，此时子进程就会成为僵尸进程。
    僵尸进程会滞留部分PCB信息在内存中，大量的僵尸进程会消耗系统的内存资源，所以要尽量避免僵尸进程产生 
    import os 
from time import sleep 

pid = os.fork()

if pid == 0:
    print("child PID:",os.getpid())
    print("parent PID again:",os.getppid())
elif pid > 0:
    print("parent process:",os.getpid())
    while True:
        pass 

#ps -aux,查看子进程pid是否是z，（z代表子进程）

     

如何避免僵尸进程产生

  • 父进程先退出
  • 父进程处理子进程退出状态

     
  • pid,status = os.wait()
  • 功能：在父进程中阻塞等待处理子进程的退出
  • 返回值：
    pid 退出的那个子进程的PID号
    status 子进程的退出状态 
  • 获取原来退出状态
    os.WEXITSTATUS(status) 
    import os 
from time import sleep 

pid = os.fork()

if pid < 0:
    print("create process faild")
elif pid == 0:
    print("Child process running")
    sleep(3)
    print("Child process over")
    os._exit(3)
else:
    #等子进程执行完毕进行回收
    pid,status = os.wait()
    print(pid,status)
    print(os.WEXITSTATUS(status)) #原来退出状态
    while True:
        pass

#Child process running
#Child process over
#3340 768
#3

     
  • pid,status = os.waitpid(pid,option)
  • 功能：在父进程中阻塞等待处理子进程的退出
  • 参数：
    pid -1 表示等待任意子进程退出
         >0 表示等待对应PID号的子进程退出
        option  0 表示阻塞等待
                 WNOHANG 表示非阻塞
  • 返回值：
    pid 退出那个子进程的PID号
    status 子进程的退出状态
  • waitpid(-1,0) ===>wait() 
    import os 
from time import sleep 

pid = os.fork()

if pid < 0:
    print("create process faild")
elif pid == 0:
    print("Child process running")
    sleep(3)
    print("Child process over")
    os._exit(3)
else:
    while True:
        sleep(1)
        pid1,status = os.waitpid(-1,os.WNOHANG)
        print(pid1,status)
        if pid1 > 0:
            break 

    while True:
        pass


     
  • 创建二级子进程
  • 父进程创建子进程等待子进程退出
  • 子进程创建下一级子进程，然后立即退出
  • 二级子进程成为孤儿，处理具体工作 
    #二级子进程处理僵尸问题

import os 
from time import sleep

def fun1():
    sleep(3)
    print("第一件事情")

def fun2():
    sleep(4)
    print("第二件事情")

pid = os.fork()

if pid < 0:
    print("create process failed")
elif pid == 0:
    #创建二级子进程
    pid1 = os.fork()
    if pid1 == 0:
        fun2() #执行fun2
    elif pid1 > 0:
        os._exit(0) #子进程退出
else:
    os.wait()
    fun1()

     

 

写一个聊天室

  功能：类似于qq群聊

  1. 进入聊天室需要输入姓名，姓名不能重复
  2. 有人进入聊天室此时会向其他人发起通知
    xxx进入了聊天室
  3. 如果一个人发消息，其它人都可以收到
    xxx说：xxxx
  4. 如果某个人退出聊天室其它人也会收到通知
    xxx 退出了聊天室
  5. 服务端可以喊话：此时群里所有人都能收到服务端消息
    管理员 说：xxx
  • 整体结构：分为几部分，如何封装，使用什么样的技术手段

     
  • 服务端
  • 客户端
  • 在客户端和服务端每个功能封装为一个函数
  • 技术方案：
    转发：一个客户发送给服务器，服务器发送给其他人
  • 套接字使用：udp完成操作
  • 用户存储：字典 或者 列表（可变类型，能够遍历提取）
                    地址  用户名
  • 发送和接收消息的控制：发送和接收使用多进程分离互不影响

     

  注意事项

  1. 注重封装
  2. 分段测试

  代码编写流程

  • 搭建通信--》创建多进程--》每个进程功能确定--》实现每一个功能模块

  功能细节梳理

  1. 进入聊天室
    1. 客户端：输入姓名
                    将信息发给我服务器  L name
    2. 服务端：接受消息
                    判断请求类型
                    判断是否可以登录（姓名是否已经存在）
                    返回给客户端是否登录（如果可以服务端会将姓名插入到存储结构）
                    给所有人发送消息
  2.   聊天
    1. 客户端：发起聊天 c msg
                    接收服务器回复
    2. 服务端：接受消息
                    判断消息类型
                    组织消息结构转发给其他客户端
  3.   退出聊天室
    1. 客户端：发送消息退出 Q name
                    接受服务
                    退出程序
    2. 服务器：接收消息
                    判断请求类型
                    从用户结构删除对应用户
                    告知所有人 xxx退出

服务器：

from socket import * 
import os,sys

#发送管理员消息
def do_child(s,addr):
    while True:
        msg = input("管理员消息:")
        msg = "C 管理员 " + msg 
        s.sendto(msg.encode(),addr)
    
#用户登录
def do_login(s,user,name,addr):
    if (name in user) or name == "管理员":
        s.sendto("该用户已存在".encode(),addr)
        return
    s.sendto(b'OK',addr)
    #通知所有人
    msg = "\n欢迎 %s 进入聊天室"%name
    for i in user:
        s.sendto(msg.encode(),user[i])
    #插入user
    user[name] = addr 

def do_chat(s,user,name,data):
    msg = "\n{} 说: {}".format(name,data)
    for i in user:
        if i != name:
            s.sendto(msg.encode(),user[i])

def do_quit(s,user,name):
    msg = "\n%s 离开了聊天室"%name 
    for i in user:
        if i == name:
            s.sendto(b'EXIT',user[i])
        else:
            s.sendto(msg.encode(),user[i])
    del user[name] #删除离开的用户


#接收客户端请求并处理
def do_parent(s):
    # 用于存储用户 {'Alex':('127.0.0.1',8888)}
    user = {}
    while True:
        msg,addr = s.recvfrom(1024)
        msgList = msg.decode().split(' ')
        if msgList[0] == 'L':
            do_login(s,user,msgList[1],addr)
        elif msgList[0] == 'C':
            # "C Levi [I miss you]"
            data = ' '.join(msgList[2:])
            do_chat(s,user,msgList[1],data)
        elif msgList[0] == 'Q':
            do_quit(s,user,msgList[1])    


# 创建套接字，网络连接，创建父子进程
def main():
    #server address
    ADDR = ('0.0.0.0',8888)
    #创建套接字
    s = socket(AF_INET,SOCK_DGRAM)
    s.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
    s.bind(ADDR)

    #创建父子进程
    pid = os.fork()
    if pid < 0:
        sys.exit("创建进程失败")
    elif pid == 0:
        do_child(s,ADDR)
    else:
        do_parent(s)

if __name__ == "__main__":
    main()

客户端：

from socket import * 
import sys,os 

def login(s,ADDR):
    while True:
        name = input("请输入用户名:")
        msg = "L " + name
        s.sendto(msg.encode(),ADDR)
        #接收登录结果
        data,addr = s.recvfrom(1024)
        if data.decode() == 'OK':
            print("@进入聊天室@")
            return name
        else:
            print(data.decode())
#发送消息
def do_child(s,name,addr):
    while True:
        text = input("发言(quit退出):")
        #退出
        if text.strip() == "quit":
            msg = "Q " + name 
            s.sendto(msg.encode(),addr)
            sys.exit("退出聊天室")

        msg = "C %s %s"%(name,text)
        s.sendto(msg.encode(),addr)

#接收消息
def do_parent(s):
    while True:
        msg,addr = s.recvfrom(1024)
        if msg.decode() == 'EXIT':
            sys.exit(0)
        print(msg.decode()+"\n发言(quit退出):",end="")

#main控制套接字的创建
def main():
    if len(sys.argv) < 3:
        print("argv is error")
        return
    HOST = sys.argv[1]
    PORT = int(sys.argv[2])
    ADDR = (HOST,PORT)

    s = socket(AF_INET,SOCK_DGRAM)
    
    name = login(s,ADDR)
    if name:
        pid = os.fork()
        if pid < 0:
            sys.exit("创建子进程失败")
        elif pid == 0:
            do_child(s,name,ADDR)
        else:
            do_parent(s)
    else:
        return 


if __name__ == "__main__":
    main()

 

multiprocessing 模块创建进程

  1. 需要将要做的事情进行封装成函数
  2. 使用multiprocessing 提供的类Process创建进程对象
  3. 通过进程对象和Process初始化进程进行进程的设置，绑定函数
  4. 启动进程，会自动执行绑定的函数
  5. 完成进程的回收

创建进程对象

Process()

  • 功能：创建进程对象
  • 参数：target：要绑定的函数
               name：给进程起的，名称（默认process-1）
               args：元组 用来给target函数位置传参
               kwargs：字典 用来给target函数键值传参

p.start()

  • 功能：启动进程 自动运行terget绑定函数，此时进程被创建

p.join([timeout])

  • 功能：阻塞等待子进程退出
  • 参数：超时时间

 

  • 使用multiprocessing创建进程子进程同样复制父进程的全部内存空间，之后有自己独立空间，执行上互不干扰
  • 子进程也是有自己特有的PID等资源
  • 如果不使用join回收可能会产生僵尸进程
  • 使用multiprocessing创建子进程，一般父进程功能就是创建子进程回收子进程，所有事件交给子进程完成 
    import multiprocessing as mp 
from time import sleep 
import os

a = 1

def fun():
    sleep(2)
    print("子进程事件",os.getpid())
    global a
    a = 10000
    print("a = ",a)

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

#启动进程
p.start() 

sleep(3)
print("这是父进程")

#回收进程
p.join()
print("parent a:",a)

# while True:
#     pass

     

作业：

  1. 梳理，聊天室代码
  2. 对进程概念和创建过程巩固
  3. 加深对http协议的理解
  4. 使用父子进程复制一个文件，分别复制文件的上半部分和下半部分到一个新的文件中，以字节区分
    解析：
    import os 
from multiprocessing import Process 
from time import sleep

#获取文件的大小
size = os.path.getsize("./timg.jpeg")
# f = open("timg.jpeg",'rb')
#复制前半部分
def copy1(img):
    f = open(img,'rb')
    n = size // 2
    fw = open('1.jpeg','wb')

    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()

#复制后半部分
def copy2(img):
    f = open(img,'rb')
    fw = open('2.jpeg','wb')
    f.seek(size // 2,0)
    while True:
        data = f.read(1024)
        if not data:
            break 
        fw.write(data)
    fw.close()
    f.close()

p1 = Process(target = copy1,args = ('timg.jpeg',))
p2 = Process(target = copy2,args = ('timg.jpeg',))
p1.start()
p2.start()
p1.join()
p2.join()

     


 

 

 

 

 

 

 

 

 

 

 

 

 

CSDN时光
关注
（五）进程相关函数，孤儿进程，僵尸进程
zh__quan的博客
07-26 234
进程相关函数使用 os.getpid() 功能：获取当前进程的PID号 返回值：返回PID号 os.getppid() 功能：获取父进程的进程号 返回值：返回PID号 os._exit(status) 功能：退出进程 参数：进程的退出状态　整数 import os  pid = os.fork() if pid &lt; 0:     print("Create Process fa...
python聊天小程序支持私聊和多人_python实现简单的多人聊天功能
weixin_42402241的博客
01-30 352
实现聊天功能1什么存储用户:列表2什么类型套接字:udp3怎么发消息:转发 即客户端发给服务器,然后在送给其他人*在客户端让发送和接收相互独立,各使用一个进程*在服务端,管理员喊话和请求接收需要独立各使用一个进程注意点:1功能封装,将每个功能模块化2测试,每个功能进行测试#代码编写流程#搭建网络连接---->>>多进程的创建----->>#每个进程功能的编写-----...
聊天室小程序服务端源码（客户端接下一条）
jettpj的博客
07-21 1588
         功能：类似qq群聊         1.进入聊天室需要输入用户名         2.有人进入聊天室有提示，其他人会收到提示            xxx进入聊天室         3.某人发消息，则其他人都能收到           xxx说：xxxx         4.有人退出聊天室其他人会收到提示           xxx退出聊天室         5.管理员功能，管理...
Python笔记（四）网络编程
aishachi2029的博客
07-06 172
一、IP地址 IP地址用来标记网络上的一台电脑，在本地局域网上是唯一的； Linux中用ifconfig命令来查看IP地址，Windows中用ipconfig命令； 禁用网卡：sudo ifconfig ens33 down 开启网卡：sudo ifconfig ens33 up IP地址的分类：IPV4、IPV6 每个IP地址由两个部分组成：网络地址、主...
基于python的聊天室程序
热门推荐
我爱吃豆芽呀
03-29 1万+
刚刚接触python编程，又从接触java开始一直对socket模块感兴趣，所以就做了一个聊天室的小程序。该程序由客户端与服务器构成，使用UDP服务，服务器端绑定本地IP和端口，客户端由系统随机选择端口。实现了群发、私发、点对点文件互传功能。客户端自建了一个类继承了Cmd模块，使用自定义的命令command进行操作，调用相应的do_command方法。使用json模块进行消息的封装序列化，在接收方...
python多线程DAY05.txt
04-27
1. 进程线程的区别和联系 * 都是多任务编程 * 一个进程包含多个线程 * 都是动态的占有资源的，线程共享进程的资源 * 进程比线程消耗资源更多 * 进程空间独立使用特定的IPC，线程使用全局变量 2. 服务器模型 ...
python多线程DAY01.txt
04-27
* 进程 线程 4. 多进程编程 时间片 PCB PID 父子进程 优先级 进程特征 进程状态： 就绪态 运行态 等待态 5. ps -aux ps -ajx pstree top nice 6. os.fork() 7. os.getpid() os.getppid() os._exit() sys.exit() ...
python多线程DAY04.txt
04-27
解决了多个进程或者线程对共享资源的争夺 Event e.set e.clear e.wait Lock lock.acquire() lock.release() 4. 什么是线程 threading Thread() t.start() t.join() t.name t.getName t.setName t.daemon...
python多线程DAY02.txt
04-27
1. 如果子进程从父进程拷贝对象，对象和网络或者文件相关联，那么父子进程会使用同一套对象属性，相互有一定的关联性 2. 如果在子进程中单独创建对象，则和父进程完全没有关联 Process进程对象属性 p.start() p....
python多线程DAY03.txt
04-27
3. 进程池 大量进程事件需要频繁创建删除进程 Pool() apply_async() close() join() map() 4.进程间通信 管道 消息队列 共享内存 信号 信号量 套接字 管道： Pipe() fd.recv() fd.send() 消息队列： ...
python 父子进程分别拷贝文件上下两部分
smart boy
08-19 522
import os size = os.path.getsize('fork.py') pid = os.fork() if pid &lt; 0: print('不想动') #子进程拷贝前半部分 elif pid == 0: n = size // 2 fw = open('child','w') with open('fork.py','r') as f: ...
python之虚拟聊天室之简单的服务器
weixin_34293246的博客
08-11 100
这是一个只有简单功能的服务器 写上来 只是为了探讨一下他的原理，以及他的工作方式，这是一个很好的敏捷开发的原型。当然这只是服务器端的，当然你自己也可以写个客户端，代码如下，接下来我们开始分析： fromasyncoreimportdispatcher fromasynchatimportasync_chat importsocket,asyncore ...
Python网络编程（子进程的创建与处理、简单群聊工具）
ParisGabriel
08-11 325
前言： 昨天我们已经了解了多进程的原理以及它的实际使用 Unix/Linux操作系统提供了一个fork()系统调用，它非常特殊。普通的函数调用，调用一次，返回一次， 但是fork()调用一次，返回两次，因为操作系统自动把当前进程（称为父进程）复制了一份（称为子进程），然后，分别在父进程和子进程内返回。 子进程永远返回0，而父进程返回子进程的ID。这样做的理由是，一个父进程可以fork出很多...
聊天室案例代码
11-10 104
#注册会员聊天 #聊天室服务器 from socket import * import sys import os import signal def do_login(s,user,name,addr): for i in user: if i == name or name == '管理员': s.sendto(b'FAIL',a...
PythonNet_05_bj
weixin_42758896的博客
12-04 287
PythonNet
Day21包和模块
weixin_50199478的博客
10-30 621
一个.py文件就是一个模块。模块是含有一系列数据、函数、类等的程序。包是将模块以文件夹的组织形式进行分组管理的方法，以便更好地组织和管理相关模块。包是一个包含一个特殊的__init__.py文件的目录。
Backtrader 数据篇 02
最新发布
进击的小学生
10-30 1015
重新自定义数据读取函数，自定义的方式就是继承数据加载类 GenericCSVData、PandasData 再构建一个新的类，然后在新的类里统一设置参数。如果传递负值（例如：-1），则表示 CSV 数据中不存在该字段自定义的函数，不会修改 Backtrader 底层的数据表格内 lines 的排列规则。
变量与数据类型：从整数到字符串
redrose2100的博客
10-30 81
变量是用于存储数据的命名空间。在Python中，定义变量非常简单，你只需要将一个值赋给变量名即可。# 定义变量x = 10变量名只能包含字母、数字和下划线（_）。变量名不能以数字开头。变量名不能为Python的关键字（如ifelsewhile等）。# 合法的变量名age = 25# 非法的变量名# 1st_num = 10 # 不能以数字开头# if = "condition" # 不能使用Python关键字。
196.245.124.255.236.194.0.0.0.0.0.0.0.0.9 用python截取最后一个点后面的数据
qq_44534541的博客
10-30 145
这个方法从字符串的右边开始分割，并且可以指定分割的最大次数。在Python中，如果你想要截取字符串中最后一个点（，因为它是最后一个点后面的数据。这段代码会处理没有点的情况（）和点的后面不是数字的情况（）后面的数据，你可以使用。
Python多线程爬虫与BeautifulSoup详解
在Python学习的Day07中，我们重点探讨了多线程爬虫和BeautifulSoup库的使用。首先，多线程在编程中的应用主要体现在I/O密集型任务上，比如网络I/O和本地磁盘I/O，这与CPU密集型的多进程任务不同。在爬虫场景中，为了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值