day33进程

进程二

一.进程的创建

• 1.1 进程创建方式一
• 1.2 进程创建方式二
• 1.3 创建进程windows和linux与mac区别
• 1.4 进程实现并发

二.进程其他知识

• 2.1 join方法
• 2.2 进程数据默认隔离
• 2.3 进程的一些属性和方法
• 2.4 僵尸进程与孤儿进程
• 2.5 守护进程

三.互斥锁

• 3.1 互斥锁的应用
• 3.2 其他锁知识

一.进程的创建

1.1 进程创建方式一

# 创建进程的本质就是在内存开辟一个新的空间运行相应的代码也可以是一份代码多个进程
from multiprocessing import Process
import time


def task(name):
    print('%s is running' % name)
    time.sleep(3)
    print('%s is over' % name)


if __name__ == '__main__':
    p = Process(target=task, args=('jason',))  # 创建一个进程对象
    p.start()  # 告诉操作系统创建一个新的进程
    print('主进程')

1.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('主进程')

1.3 创建进程windows和linux与mac区别

​ 在windows中创建进程是以导入模块的方式进行 所以创建进程的代码必须写在__main__子代码中否则会直接报错 因为在无限制创建进程

​ 在linux和mac中创建进程是直接拷贝一份源代码然后执行 不需要写在__main__子代码中

1.4 进程实现并发

# 服务端
import socket
from multiprocessing import Process

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'))
        info=f'服务端{data}'
        info=info.encode()
        sock.send(info)

if __name__ == '__main__':
    server=get_server()
    while True:
        sock, addr = server.accept()
        p = Process(target=talk, args=(sock, ))
        p.start()
# 客户端1
import socket


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

while True:
    info=input('>>>:').strip().encode()
    client.send(info)
    data = client.recv(1024)
    print(data.decode('utf8'))
# 客户端二
import socket


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

while True:
    info=input('>>>:').strip().encode()
    client.send(info)
    data = client.recv(1024)
    print(data.decode('utf8'))

二.进程其他知识

2.1 join方法

# 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()
    p1.join()
    p2.join()
    p3.join()
    end_time = time.time() - start_time
    print('主进程', f'总耗时:{end_time}') 

2.2 进程数据默认隔离

# 内存可以看成是有很多个小隔间组成的 彼此不干扰
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)
"""默认隔离  但是可以通过一些技术打破"""

2.3 进程的一些属性和方法

"""
进程号如何查看
	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()

2.4 僵尸进程与孤儿进程

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

2.5 守护进程

"""
守护即死活全部参考守护的对象
	对象死立刻死
"""
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('皇帝Jason寿终正寝')

三. 互斥锁

3.1 互斥锁模拟抢票

import json
import multiprocessing import Process,Lock
import time
import random
# 查票接口
def search(name):
    wieh 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:
        lock.acquire()
        data['ticket_num'] -= 1
        with open(r'ticket_data.json', 'w', encoding='utf8') as f:
            json.dump(data, f)
        lock.release()
        print(f'{name}抢票成功')
    else:
        print(f'{name}抢票失败 没有余票了')


def run(name):
    search(name)
    buy(name)
# 模拟多人同时抢票
if __name__ == '__main__':
    lock=Lock()
    for i in range(1, 10):
        p = Process(target=run, args=('用户:%s' % i,lock))
        p.start()

3.2 其他锁知识

行锁:针对行数据加锁 同一时间只能一个人操作
表锁:针对表数据加锁 同一时间只能一个人操作

悲观锁：每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会block直到它拿到锁。传统的关系型数据里边
就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁

乐观锁：每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制，
乐观锁适用于多读的应用类型，这样可以提高吞吐量