4.19python笔记

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

进程创建

​ 在python中提供了一个multiprocessing模块可以帮助我们使用多进程解决问题。在multiprocessing 模块中有一个类Process。

#第一种方法(函数对象作为进程）：
	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__子代码中
"""

#第二种方法 (用class类创建)
	from multiprocessing import Process

    class Test(Process):
        def __init__(self,name):
            super().__init__()
            self.name = name

        def run(self):
            print(self.name)
    if __name__ == '__main__':
        p = Test('test')
        p.start()
        print('主')
    #自定义类主要是改写他的run()方法，run()方法在调用start()方法时一定会被调用

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方法会让子进程执行完再执行主进程

进程实现并发

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

服务端

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

进程间数据默认隔离

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

进程对象属性和方法

# 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.僵尸进程
　僵尸进程：一个进程使用fork创建子进程，如果子进程退出，而父进程并没有调用wait或waitpid获取子进程的状态信息，那么子进程的进程描述符仍然保存在系统中。这种进程称之为僵死进程。
    '''
        僵死进程：子进程退出后，会将该进程的重型资源释放掉（cpu，内存，打开的文件），子进程的进
程描述符仍然保存在系统中，比如pid。
    '''
    所有的子进程在运行结束之后都会变成僵尸进程(死了没死透)
    程序正常结束才会产生僵尸进程，如果强制关闭父进程，操作系统会把父进程已经运行结束的子进程全部删除，也就不会产生僵尸进程了。
    僵尸进程的危害:
      系统的pid号是有限的，僵尸进程保留的信息如果一直不被释放，一直累计会导致没有可用的pid号而导致系统不能产生新的进程
#2.孤儿进程
 	孤儿进程(无害)：一个父进程退出，而它的一个或多个子进程还在运行，那么那些子进程将成为孤儿进程。孤儿进程将被init进程(进程号为1)所收养，并由init进程对它们完成状态收集工作。
   '''
      子进程存活着 父进程意外死亡
      子进程会被操作系统自动接管(儿童福利院)
   '''

互斥锁

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

#为什么：
因为你某一时间打开买票软件查看票数，看的是这一时间的数据，只要不刷新不点击下一步，展示的永远是这个时间的数据
那么这个是如何实现的呢，这个就需要使用互斥锁了。

#代码模拟：
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()  # 放锁

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