网络编程：进程概念及方法、僵尸进程及孤儿进程、守护进程、互斥锁（重要）

2022.4.19进程相关操作、方法、概念

• 代码创建进程
• join方法
• 进程间数据默认隔离
• 进程对象相关属性和方法
• 僵尸进程和孤儿进程
• 守护进程
• 互斥锁（重要）

一、代码创建进程

问题：创建进程的方式有哪些？

（1）鼠标双击桌面程序图标

（2）代码创建

创建进程的本质：

在内存中申请一块内存空间用于运行相应的程序代码

1、第一种(函数对象作为进程）：

from multiprocessing import Process
import time

def task(name):
    print('%s is runing' % name)
    time.sleep(3)
    print('%s is over' % name)
    
if __name__ == '__main__':
    p = Process(target=task, args=('json',))  # 创建进程对象，指定为task，args指定数据，必须加逗号以元组形式传入
    p.start()  # 告诉系统创建一个新的进程
    print('主进程')
注意：
"""
强调:不同的操作系统创建进程的要求不一样
    在windows中创建进程是以导入模块的方式进行 所以创建进程的代码必须写在__main__子代码中
    否则会直接报错 因为在无限制创建进程
    在linux和mac中创建进程是直接拷贝一份源代码然后执行 不需要写在__main__子代码中
"""

2、第二种（类对象作为进程）：

from multiprocessing import Process
import time

class MyProcess(Process):
    def __init__(self, username):
        self.username = username
        super().__init__()
    def run(self):
        print('你好啊 小姐姐',self.username)
        time.sleep(3)
        print('get out!!!',self.username)
if __name__ == '__main__':
    p = MyProcess('tony')  # 创建进程对象
    p.start()  # 创建进程
    print('主进程')

# 主进程
# 你好啊 小姐姐 tony
# get out!!! tony
由此可见进程相当于进行异步操作了

3、进程实现并发

将与客户端通信的代码封装成一个函数
之后每来一个客户端就创建一个进程专门做交互

服务端：

import socket
from multiprocessing import Process

# 封装一个get_server，这个创建进程就不会反复执行里面的代码
# 从而避免报地址只允许使用一次的错误
def get_server():
    server = socket.socket()
    server.bind(('127.0.0.1', 8080))
    server.listen(5)
    return server

# 将服务客户端的代码封装成函数(通信代码)
def talk(sock):
    while True:
        data = sock.recv(1024)
        print(data.decode('utf8'))
        sock.send(data.upper())

if __name__ == '__main__':
    server = get_server()
    while True:
        sock, addr = server.accept()
        p = Process(target=talk, args=(sock, ))
        p.start()

客户端：

import socket

client = socket.socket()
client.connect(('127.0.0.1', 8080))

while True:
    client.send(b'hello big baby~')
    data = client.recv(1024)
    print(data.decode('utf8'))

二、join方法

作用：让主进程代码等待子进程代码运行完毕再执行

from multiprocessing import Process
import time

def task(name, n):
    print(f'{name} is runing')
    time.sleep(n)
    print(f'{name} is over')
    
if __name__ == '__main__':
    p1 = Process(target=task, args=('jason', 1))
    p2 = Process(target=task, args=('tony', 2))
    p3 = Process(target=task, args=('kevin', 3))
    start_time = time.time()
    p1.start()
    p2.start()
    p3.start()
    p1.join()
    p2.join()
    p3.join()
    end_time = time.time() - start_time
    print('主进程', f'总耗时:{end_time}')  # 主进程 总耗时:3.015652894973755，因为上面进程已经陆续开始，因此各进程是相互重叠的
    # 如果是一个start一个join交替执行 那么总耗时就是各个任务耗时总和，因为join方法会让子进程执行完再执行主进程

三、进程间数据默认隔离

引入：内存可以看成很多个小隔间，彼此互不干扰

from multiprocessing import Process

money = 999
def task():
    global money  # 局部修改全局不可变类型
    money = 666
    print(money)

if __name__ == '__main__':
    p = Process(target=task)
    p.start()
    p.join()  # 确保子进程代码运行结束再打印money
    print(money)
结果：
666
999
 
"""默认隔离  但是可以通过一些技术打破，后面会了解"""

四、进程对象属性和方法

如何查看进程号？

# windows系统:
tasklist结果集中PID
# mac系统
ps -ef
# python代码查看
  1.current_process函数
  	from multiprocessing import Process, current_process
        current_process().pid
 	# 获取进程号的用处之一就是可以通过代码的方式管理进程
  	windows  	taskkill关键字
        mac/linux       kill关键字
  2.os模块
  	os.getpid()  # 获取当前进程的进程号
        os.getppid()  # 获取当前进程的父进程号
# 杀死子进程
terminate()
# 判断子进程是否存活
is_alive()

五、僵尸进程和孤儿进程

1、僵尸进程

问题：为什么主进程默认要等待子进程执行结束返回结果才会结束？

答：所有的子进程在运行结束之后都会变成僵尸进程（死了没死透），

还保留着pid和一些运行过程中的记录便于主进程查看（短时间保存），

这些信息会被主进程回收时僵尸进程彻底死亡，以下情况将杀死运行结束后的僵尸进程
1.主进程正常结束
2.调用join方法

2、孤儿进程

状态：子进程存活着，父进程意外死亡

子进程会被操作系统自动接管（eg：儿童福利院）

六、守护进程

守护进程：

即设置为守护进程的进程对象，会随着守护的进程对象结束而结束

from multiprocessing import Process
import time

def task(name):
    print(f'大内总管:{name}正常活着')
    time.sleep(3)
    print(f'大内总管:{name}正常死了')

if __name__ == '__main__':
    p = Process(target=task, args=('赵公公',))
    p.daemon = True # 将p设为守护进程
    p.start()
    print('皇帝寿终正寝了啊')
    
# 结果：
皇帝寿终正寝了啊
大内总管:赵公公正常活着  # 只打印一个出来，因为主进程死亡，守护进程还没运行完，直接结束

七、互斥锁（重要）

引入（抢票问题）：

为什么手机上明明显示还有余票，但是点击购买的时候却提示已经没有票了，之后回到查询页面再查询发现确实没票了。

为什么：

因为你某一时间打开买票软件查看票数，看的是这一时间的数据，只要不刷新不点击下一步，展示的永远是这个时间的数据

那么这个是如何实现的呢，这个就需要使用互斥锁了。

代码模拟：

import json
from multiprocessing import Process
import time
import random

# ticket_data.json文件内容：{"ticket_num": 0}

# 查票
def search(name):
    with open(r'ticket_data.json', 'r', encoding='utf8') as f:
        data = json.load(f)
    print(f'{name}查询当前余票:%s' % data.get('ticket_num'))
    
# 买票
def buy(name):
    # 1.点击买票是需要再次查票的 因为期间其他人可能已经把票买走
    with open(r'ticket_data.json', 'r', encoding='utf8') as f:
        data = json.load(f)
    time.sleep(random.randint(1, 3))
    # 2.判断是否还有余票
    if data.get('ticket_num') > 0:
        data['ticket_num'] -= 1
        with open(r'ticket_data.json', 'w', encoding='utf8') as f:
            json.dump(data, f)
        print(f'{name}抢票成功')
    else:
        print(f'{name}抢票失败 没有余票了')
        
def run(name):
    search(name)
    buy(name)
    
# 模拟多人同时抢票
if __name__ == '__main__':
    for i in range(1, 10):
        p = Process(target=run, args=('用户:%s' % i,))
        p.start()
# 问题：
上面模拟了买票的基本逻辑，但是有一个问题，如果同时抢票的话，多个子进程获得的数据都一样，都会显示抢票成功，造成数据的错乱然，怎么办？
答：并发--->串行（牺牲效率保证数据安全）--->互斥锁
# 注意：
1.互斥锁并不能轻易使用 容易造成死锁现象
2.互斥锁只在处理数据的部分加锁，不能什么地方都加，严重影响程序的效率

互斥锁：

from multiprocessing import Process, lock

mutex = lock()  # 定义互斥锁
mutex.acquire()  # 抢锁
mutex.release()  # 放锁

结合抢票软件，我们应该把锁加在购买票的时候

def run(name, mutex):
    search(name)
    # 只需要把买票环节变成串行即可
    mutex.acquire()  # 抢锁
    buy(name)
    mutex.release()  # 放锁

注意：加锁购买之后一定要放锁，不然会一直卡在这个用户手里

锁相关知识：

锁相关知识
行锁:针对行数据加锁 同一时间只能一个人操作
表锁:针对表数据加锁 同一时间只能一个人操作
锁的应用范围很广 但是核心都是为了保证数据的安全!!!