进程详解

进程详解

• 代码创建进程
• 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=('tony',))
    # 告诉操作系统创建一个新的进程
    p.start()
    print('这是主进程')

2.代码创建的第二种方式

class MyProcess(Process):
    def __init__(self,username):
        self.username = username
        super().__init__()
    def run(self):
        print('你好啊，小姐姐',self.username)
        time.sleep(5)
        print('get out!!!',self.username)
if __name__ == '__main__':
    p = MyProcess('tony')
    p.start()
    print('这是主进程!!!')

进程实现并发

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

def talk(sock):
    while True:
        data = sock.recv(1024)
        print(data.decode('utf8'))
        sock.send(data.upper())
if __name__ == '__main__':
    while True:
        sock, addr = server.accept()
        p = Process(target=talk, args=(sock, ))
        p.start()

join方法

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

from multiprocessing import Process
import time
def task(name, n):
    print(f'{name} is running')
    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()
    p3.join()
    p1.join()
    p2.join()
    end_time = time.time() - start_time
    print(end_time)

如果是一个start一个join交替执行 那么总耗时就是各个任务耗时总和

进程间数据默认隔离

from multiprocessing import Process
money = 999
def task():
    global money  # 局部修改全局不可变类型
    money = 666
if __name__ == '__main__':
    p = Process(target=task)
    p.start()
    p.join()  # 确保子进程代码运行结束再打印money
    print(money)

默认隔离 但是可以通过一些技术打破

进程对象属性和方法

进程号如何查看
windows: tasklist结果集中PID
mac: ps -ef

1.查看进程号的方法
	1.1.current_process函数
  	from multiprocessing import Process, current_process
    current_process().pid
 	# 获取进程号的用处之一就是可以通过代码的方式管理进程
  	windows  			taskkill关键字
    mac/linux  		kill关键字
  1.2.os模块
  	os.getpid()  # 获取当前进程的进程号
    os.getppid()  # 获取当前进程的父进程号
2.杀死子进程
	terminate()
3.判断子进程是否存活
	is_alive()

僵尸进程与孤儿进程

僵尸进程
	# 为什么主进程默认需要等待子进程结束才会结束
  所有的子进程在运行结束之后都会变成僵尸进程(死了没死透)
  还保留着pid和一些运行过程的中的记录便于主进程查看(短时间保存)
  这些信息会被主进程回收(僵尸彻底死了)
  	1.主进程正常结束
    2.调用join方法
孤儿进程
	# 子进程存活着 父进程意外死亡
  子进程会被操作系统自动接管(儿童福利院)

守护进程

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=('子进程',))
    # 必须写在start前面
    # 将子进程设置为守护进程:主进程结束 子进程立刻结束
    p.daemon = True  
    p.start()
    print('主进程寿终正寝')

互斥锁

import json
from multiprocessing import Process, Lock
import time
import random
# 查票
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, mutex):
    search(name)
    # 只需要把买票环节变成串行即可
    mutex.acquire()  # 抢锁
    buy(name)
    # mutex.release()  # 放锁
# 模拟多人同时抢票
if __name__ == '__main__':
    # 互斥锁在主进程中产生一把 交给多个子进程用
    mutex = Lock()
    for i in range(1, 10):
        p = Process(target=run, args=('用户:%s' % i, mutex))
        p.start()

当多个进程操作同一份数据的时候会造成数据的错乱！！！

这个时候需要加锁处理(互斥锁)

将并发变成串行 牺牲了效率但是保证的数据的安全

互斥锁并不能轻易使用 容易造成死锁现象

互斥锁只在处理数据的部分加锁 不能什么地方都加 严重影响程序的效率

查票可以一次性给所有人看 但是买票环节必须'排队'>>>:互斥锁

from multiprocessing import Process, Lock

mutex = Lock()

mutex.acquire() # 抢锁

mutex.release() # 放锁

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