代码创建进程、join方法、进程间数据默认隔离、进程对象相关属性和方法、僵尸进程与孤儿进程(纯理论)、守护进程、互斥锁(重要)

代码创建进程

'''
创建进程的方式有哪些：
	1.鼠标双击桌面一个应用图标
    2.代码创建
'''
创建进程的本质：再内存中申请一块内存空间用于运行相应的程序代码
# 利用multiprocessing模块创建进程的两种方式.
注意：
	不同的操作一同创建进程的要求不一样
    在windows中创建进程是以导入模块的方式进行，所以创建进程的代码必须写在__main__子代码中，否则会直接报错，因为在无限制的创建进程
    在linux和mac中创建进程是直接拷贝一份源代码然后执行，不需要写在__mian__子代码中
# from multiprocessing import Process
# import time
#
#
# def task(name):
#     print(f'{name} is running')
#     time.sleep(1.5)
#     print(f'{name} is over')
#
#
# if __name__ == '__main__':
#     p = Process(target=task, args=('tuzi',))  # 创建一个进程对象
#     p.start()  # 告诉操作系统创建一个新的进程
#     print('主进程')

# 输出结果
# 主进程
# tuzi is running
# tuzi is over


# 第一种创建进程的方式>>>以类创建

from multiprocessing import Process
import time


class Myclass(Process):
    def __init__(self, username):
        self.username = username
        super().__init__()

    def run(self):
        print('hello baby', self.username)
        time.sleep(1.5)
        print('good bay', self.username)


if __name__ == '__main__':
    p = Myclass('tuzi')
    p.start()
    print('主进程')

# 输出结果
# 主进程
# hello baby tuzi
# good bay tuzi

思考:如何让TCP服务端实现并发的效果

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

# 服务器端：
import socket
from multiprocessing import Process


def get_server():
    server = socket.socket()
    server.bind(('127.0.0.1', 8888))
    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', 8888))
while True:
    msg = input('回复消息>>>:').strip()
    if len(msg) == 0:
        continue
    client.send(msg.encode('utf8'))
    data = client.recv(1024)

    print(data.decode('utf8'))

join方法

让主进程代码等待子进程代码运行完毕再执行
掌握:join方法的简单使用
    如何真正理解等待的过程

"""
需求:想让p.start()之后的代码 等待子进程全部运行结束之后再打印
    1.sb做法:直接sleep
        肯定不行 因为子进程运行的时间不可控
    2.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=('tuzi', 1))
    p2 = Process(target=task, args=('tony', 2))
    p3 = Process(target=task, args=('jason', 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}')
    # 输出结果：
    # tony is running
    # jason is running
    # tuzi is running
    # tuzi is over
    # tony is over
    # jason is over
    # 主进程
    # 总耗时: 3.142277717590332
    # 如果是一个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)

进程对象属性和方法

进程号：每个进程都由一个进程号来标识，其类型为 pid（无符
号整型），进程号总是唯一的，但进程号可以重用。当一个进程终止
后，其进程号就可以再次使用。

查看进程号的方法

利用操作系统查看

windows: 			tasklist结果集中PID
mac:				ps -ef

利用代码查看

# 1.current_process函数
from multiprocessing import current_process
print(current_process().pid)  # 12784
# 获取进程号的用处之一就是可以利用代码的方式管理进程
windows        		taskkill关键字
mac/linux			kill关键字
# 2.os模块
os.getpid()  # 获取当前进程的进程号
os.getppid()  # 获取当前进程的父进程号
# 杀死子进程
terminate()
# eg：
import time
from multiprocessing import Process
import os
def task():
    print('子进程号：',os.getpid())
    print('父进程号：',os.getppid())


if __name__ == '__main__':
    p = Process(target=task)
    p.start()
    p.terminate()  # 告诉操作系统杀死子进程，但需要一点时间
    time.sleep(0.1)
    print(p.is_alive())  # False
    print('主进程')
# 3.判断子进程是否存活
	is_alive()
    # 返回值是True，False

僵尸进程与孤儿进程

僵尸进程

所有的子进程在运行结束之后都会变成僵尸进程(死了没死透)
还保留着pid和一些运行过程的中的记录便于主进程查看(短时间保存)
这些信息会被主进程回收(僵尸彻底死了)
1.主进程正常结束
2.调用join方法

孤儿进程

孤儿进程
	# 子进程存活着 父进程意外死亡
  子进程会被操作系统自动接管(儿童福利院)

守护进程

"""
守护即死活全部参考守护的对象
	对象死立刻死
"""
from multiprocessing import Process
import time

def task(name):
    print(f'大哥{name}还活着')
    time.sleep(1.5)
    print(f'大哥{name}没了')

if __name__ == '__main__':
    p = Process(target=task,args=('玛卡巴卡',))
    # 必须写在start前面
    p.daemon = True  # 将子进程设置为守护进程：主进程结束子进程立刻结束
    p.start()
    print('结束了')

互斥锁(重要)

当多个进程操作同一份数据的时候会造成数据的错乱
这个时候需要加锁处理(互斥锁)
将并发变成串行  牺牲了效率但是保证数据的安全

互斥锁不能轻易的使用，容易造成死锁现象
互斥锁只在处理数据的部分加锁，不能什么地方都加，严重影响程序的效率
# 比如：查票可以一次性给所有人看，但是买票环节必须排队 >>>:互斥锁
from multiprocessing import Process, Lock
mutex = Lock()
mutex.acquire()  # 抢锁
mutex.release()  # 放锁

行锁、表锁

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

锁的应用范围很广，但是核心都是为了保证数据的安全
'''

乐观锁悲观锁

悲观锁：对每次访问数据库的操作都是抱有悲观的态度，认为该操作会对数据库做出修改，所以在访问数据库的时候就加了锁

乐观锁：对每次访问数据库的操作都抱有乐观的态度，只有在做出修改的时候才会上锁

互斥锁应用

代码模拟抢票

"""
每逢节假日抢票
	手机上明明显示还有余票 但是点击购买的时候却提示已经没有票了
	之后回到查询页面发现确实显示没有票了

上午10:00打开买票软件查看票数 系统给你发过来的是10:00对应的数据
只要你页面不刷新不点击下一步 那么页面数据永远展示的是10:00的
"""

代码展示

import json
import random
from multiprocessing import Process
import time


# 查票
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):
    # 查票
    with open(r'ticket_data.json', 'r', encoding='utf8') as f:
        data = json.load(f)
    time.sleep(random.randint(1, 3))
    # 判断是否还有余票
    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(10):
       p = Process(target=run, args=(f'用户{i}',))
        p.start()