二十七、多进程，互斥锁

一、创建进程

创建进程就是在内存中重新开辟一块内存空间
将允许产生的代码丢进去
一个进程对应在内存就是一块独立的内存空间,和其他之间没有任何关系，变量也是独立的

进程与进程之间数据是隔离的 无法直接交互
但是可以通过某些技术实现间接交互
"""

如果调用函数，势必会同步等待时间结束完，才会执行其他代码，这里就是多进程同时执行，无需等待。 os.getpid() 显示进程数

os.getppid())  # 查询当前进程的父进程是谁
主程序和子程序在异步过程中，是随机运行的
两种方式：

　1.第一种：　　　

from multiprocessing import Process
import time
import os


def test(name):
    print('%s is running' % name, os.getpid())
    print('子进程父进程：', os.getppid())
    time.sleep(3)
    print('%s is over' % name, os.getpid())
    print('子进程父进程：', os.getppid())


"""
windows创建进程会将代码以模块的方式 从上往下执行一遍
linux会直接将代码完完整整的拷贝一份


windows创建进程一定要在if __name__ == '__main__':代码块内创建  否则报错
"""
if __name__ == '__main__':
    p = Process(target=test, args=('子进程：',))  # 注册 创建一个进程对象       p是一个进程对象
    p.start()  # 告诉操作系统帮你开启子进程，
    print('父进程：', os.getpid())  # 查询当前进程数字
    print('父进程父进程：', os.getppid())  # 查询当前进程的父进程是谁

2.第二方法：

import os
from multiprocessing import Process


class MyProcess(Process):
    def __init__(self, arg1, arg2):
        super().__init__() #初始化到父类，下面是派生属性
        self.arg1 = arg1
        self.arg2 = arg2

    def run(self):
        print(self.arg1,self.arg2)
        print(self.pid)  # 等同于os.getpid()
        print(self.name)
        print("子进程：", os.getpid())


if __name__ == '__main__':
    # print("主进程：", os.getpid())
    p1 = MyProcess(1,2)
    p1.start()
    p2 = MyProcess(3,4)
    p2.start()
    print("主进程：", os.getpid())

二、开启多个字进程，p.join()使用方法

join（）：

主进程代码等待子进程运行结束

p.join()上面是异步执行（子程序），下面是同步执行（主程序），没有p.join()都是异步

from multiprocessing import Process
import time

def test(name, i):
    print('%s is running' % name)
    time.sleep(i)
    print('%s is over' % name)

if __name__ == '__main__':
    p_list = []
    for i in range(3):
        p = Process(target=test,args=('进程%s'%i,i))
        p.start()
        p_list.append(p)
    [p.join() for p in p_list]
　　 # start_time =time.time()
    # p = Process(target=test, args=('egon', 1))
    # p1 = Process(target=test, args=('kevin', 2))
    # p2 = Process(target=test, args=('jason', 3))
    # p.start()  # 仅仅是告诉操作系统帮你创建一个进程 至于这个进程什么时候创  操作系统随机决定
    # p1.start()
    # p2.start()
    # p2.join()
    # p.join()
    # p1.join()

    # 主进程代码等待子进程运行结束 才继续运行
    # p.join()  # 主进程代码等待子进程运行结束
    print('主')
    print(time.time() - start_time)

三、进程与进程之间隔离

　　进程与进程之间是相互隔离，都是独立的一块内存空间，数据不共享

from multiprocessing import Process

money = 100


def test():
    global money
    money = 99999999


if __name__ == '__main__':
    p = Process(target=test)
    p.start()
    p.join()
    print(money) #100

 四、守护进程

把子进程改为守护进程，在start（）上面添加p.daemon，子进程会随着主进程的结束而结束

def test(name):
    while True:
        print('%s总管正常活着' % name)
        time.sleep(3)
        print('%s总管正常死亡' % name)


if __name__ == '__main__':
    p = Process(target=test, args=('egon',))
    p.daemon = True  # 将该进程设置为守护进程   这一句话必须放在start语句之前 否则报错
    p.start()
    i = 0
    while i < 10:
        time.sleep(0.1)
        print('皇帝jason寿正终寝')
        i += 1

# 随着主进程的结束而结束

五、互斥锁

from multiprocessing import Process, Lock
import time
import json


# 查票
def search(i):
    with open('data', 'r', encoding='utf-8') as f:
        data = f.read()
    t_d = json.loads(data)
    print('用户%s查询余票为:%s' % (i, t_d.get('ticket')))


# 买票
def buy(i):
    with open('data', 'r', encoding='utf-8') as f:
        data = f.read()
    t_d = json.loads(data)
    time.sleep(1)
    if t_d.get('ticket') > 0:
        # 票数减一
        t_d['ticket'] -= 1
        # 更新票数
        with open('data', 'w', encoding='utf-8') as f:
            json.dump(t_d, f)
        print('用户%s抢票成功' % i)
    else:
        print('没票了')


def run(i, mutex):
    search(i)
    mutex.acquire()  # 抢锁  只要有人抢到了锁 其他人必须等待该人释放锁
    buy(i)
    mutex.release()  # 释放锁


if __name__ == '__main__':
    mutex = Lock()  # 生成了一把锁
    for i in range(10):
        p = Process(target=run, args=(i, mutex))
        p.start()

 六、死锁（递归锁）

死锁：同一段代码，如果出现两把或两把以上锁就会出现 死锁 （多进程和多线程都会出现）

from threading import Lock, Thread
import time

noodle_lock = Lock()
fork_lock = Lock()


def eat1(name):
    noodle_lock.acquire()
    print("%s拿到面条啦！" % name)
    fork_lock.acquire()
    print("%s拿到叉子了" % name)
    print("%s可以吃面楼！" % name)
    fork_lock.release()
    noodle_lock.release()


def eat2(name):
    fork_lock.acquire()
    print("%s拿到叉子了2" % name)
    time.sleep(1)
    noodle_lock.acquire()
    print("%s拿到面条啦2！" % name)
    print("%s可以吃面楼2！" % name)
    noodle_lock.release()
    fork_lock.release()


Thread(target=eat1, args=("alex",)).start()
Thread(target=eat2, args=("json",)).start()
Thread(target=eat1, args=("tank",)).start()
Thread(target=eat2, args=("jirry",)).start()
# 锁是共通的，两个函数锁相互抢（如果没有阻塞就没问题）

递归锁：Rlock 是一串钥匙，拿到了就可以路通到底

# 锁是唯一的，全局变量

#递归锁：Rlock 是一串钥匙，拿到了就可以路通到底
from threading import RLock, Thread

import time

fork_lock=noodle_lock = RLock()  # RLOCK递归锁，一个钥匙串上两把钥匙

def eat1(name):
    noodle_lock.acquire()
    print("%s拿到面条啦！" % name)
    fork_lock.acquire()
    print("%s拿到叉子了" % name)
    print("%s可以吃面楼！" % name)
    fork_lock.release()
    noodle_lock.release()


def eat2(name):
    fork_lock.acquire()
    print("%s拿到叉子了" % name)
    time.sleep(1)
    noodle_lock.acquire()
    print("%s拿到面条啦！" % name)
    print("%s可以吃面楼！" % name)
    noodle_lock.release()
    fork_lock.release()


Thread(target=eat1, args=("alex",)).start()
Thread(target=eat2, args=("json",)).start()
Thread(target=eat1, args=("tank",)).start()
Thread(target=eat2, args=("jirry",)).start()