8.9 day30 并发编程进程理论进程方法守护进程互斥锁

多道技术

1.空间上的复用

多个程序共用一套计算机硬件

多道技术原理

2.时间上的复用

切换+保存状态

    1.当一个程序遇到IO操作 操作系统会剥夺该程序的CPU执行权限( 提高了CPU的利用率，并且也`不影响程序的执行效率` )

    2.当一个程序长时间占用CPU 操作系统也会剥夺该程序的CPU执行权限( `降低了程序的执行效率` )

并发: 看起来像同时运行就可以

并行: 真正意义上的同时运行

    单核的计算机不能实现并行，但是可以实现并发

进程

程序和进程的区别

程序: 一段代码

进程: 正在进行的程序 进程相互独立

进程调度

要想多个进程交替运行，操作系统必须对这些进程进行调度，这个掉浮是遵循一定法则的，这就是进程的调度算法

先来先服务（最简单的调度算法，有利于长作业，不利于短作业）
短作业优先算法（短作业优先，对短作业有利，对长作业不利）
时间片轮转法+多级反馈队列

时间片: 就好比将一秒等分成N多份

如果一个程序他需要更多的时间片，这个程序的执行优先级就会下降，比如A程序在运行，此时用户点击了B程序，那操作系统就会立刻停止A程序的执行，保存A程序的运行进度，然后去响应B程序
大概就这些？

进程三态状态转换图

在了解其他概念之前，我们首先要了解进程的几个状态。在程序运行的过程中，由于被操作系统的调度算法控制，程序会进入几个状态：就绪，运行和阻塞。

　　（1）就绪(Ready)状态

　　当进程已分配到除CPU以外的所有必要的资源，只要获得处理机便可立即执行，这时的进程状态称为就绪状态。

　　（2）执行/运行（Running）状态当进程已获得处理机，其程序正在处理机上执行，此时的进程状态称为执行状态。

　　（3）阻塞(Blocked)状态正在执行的进程，由于等待某个事件发生而无法执行时，便放弃处理机而处于阻塞状态。

引起进程阻塞的事件可有多种，

例如，等待I/O完成、申请缓冲区不能满足、等待信件(信号)

input

print

文件操作

sleep

...其他的

结束阻塞态

input获取到值

print输出完结果

文件读取完毕

睡眠结束。

时间片的时间到了（占用CPU太久了）会自动进入就绪态，而不是阻塞，等待下一次CPU执行

写程序的理想状态: 尽量少的进入阻塞态

同步异步

表示的是任务的提交方式

同步：任务提交以后，原地等待的任务的执行并拿到返回结果才走，期间不做任何事（程序界面的表现就是

异步：任务提交以后，不再原地等待，而是继续执行下一行代码（结果是要的但是用其他方式获取）

import time

def test()

		time.sleep()

res = test()

print('hello')

阻塞非阻塞

表示的是程序的运行状态

阻塞: 对应进程三状态中的阻塞态

非阻塞: 对应进程三状态中的就绪态、运行态

异步非阻塞形式效率最高

创建进程的两种方式

创建进程就是在内存中重新开辟一块内存空间

将运行产生的代码丢进去

一个进程对应在内存就是一块独立的内存空间

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

这两种必须敲出来

from multiprocessing

...

def test(name):

    print('%s is running' %name)

    time.sleep(3)

    print('%s is over' %name)

"""

Windows 创建进程会将代码以模块的方式从上往下执行一遍

Linux 会直接将代码完完整整的拷贝一份（fork一份）

windows创建进程一定要在 if __name__ == '__main__': 代码块内创建 否则报错

"""

if __name__ == '__main__':

    p = Process(target = test,args = ('margo',))  # 创建一个进程对象

    p.start()  # 告诉操作系统帮你创建一个进程

    print('主')  # 为什么先打印’主‘

    #因为创建p.start()这个进程的时间远远大于执行接下来语句的时间

"""

创建进程就是在内存中重新开辟一块内存空间

将允许产生的代码丢进去

一个进程对应在内训就是一块独立的内存空间

进程与进程之间数据是隔离的 无法直接交互

( 可以通过某些技术间接进行交互 )

只要开一个进程就是重新申请一块内存空间

零散知识点

join方法

from multiprocessing import Process

from multiprocessing import Process

def test(name):

    print('%s is running'% name)

    time.sleep(3)

    print('%s is over'% name)

p = Prosess(target = test,args = ('margo',))

p.start()

print('主')

# 这样会报错 要把三行 放在main里面

if __name__ == '__main__':

    p = Prosess(target = test,args = ('margo',))

    p.start()

    # 主进程代码等待子进程运行结束 才继续进行

    print('主')

# 用join

if __name__ == '__main__':

    p = Prosess(target = test,args = ('margo',))

    p.start()

    # 主进程代码等待子进程运行结束 才继续进行

    p.join()

    print('主')

if __name__ == '__main__':

    p = Prosess(target = test,args = ('margo',))

    p1 = Prosess(target = test,args = ('margo',))

    p2 = Prosess(target = test,args = ('margo',))

    p.start()  # 仅仅是告诉操作系统帮你创建一个进程

    p1.start()  # 创建进程的顺序是随机的

    p2.start()  # 至于这个进程什么时候创，操作系统随机决定

    # 主进程代码等待子进程运行结束 才继续进行

    p.join()

    print('主')

if __name__ == '__main__':

    for i in range(3):

        p = Process(target = )

    p = Prosess(target = test,args = ('margo',))

    p1 = Prosess(target = test,args = ('margo',))

    p2 = Prosess(target = test,args = ('margo',))

    p.start()  # 仅仅是告诉操作系统帮你创建一个进程

    p1.start()  # 创建进程的顺序是随机的

    p2.start()  # 至于这个进程什么时候创，操作系统随机决定

    # 主进程代码等待子进程运行结束 才继续进行

    p.join()

    print('主')

06 进程间数据是隔离的

money = 100

07 进程对象及其他方法

查看主主进程

getpid getppid

杀死进程

terminate 杀死当前进程其实是告诉操作系统

time.sleep(0.1)

p.is_alive()

僵尸进程与孤儿进程

	父进程回收子进程资源的两种方式：

		1.join方法

		2.父进程正常死亡

	所有的进程都会步入僵尸进程

	孤儿进程

			子进程没死 父进程意外死亡

			针对Linux会有儿童福利院(init)(只是个名字 别搞混)，如果父进程意外死亡，他所创建的子进程都会被福利院收养

守护进程

被守护进程结束后守护进程立刻结束（后面的还未执行的代码直接不执行了）

from multiprocessing import Process

import time

# 古代皇帝死了一般太监都需要陪葬，所以举这么一个例子

def test(name):

    print(f'{name}总管正常活着')

    time.sleep(3)

    print(f'{name}总管正常死亡')

# # windows下创建子进程必须卸载 __main__ 这个结构里

# if __name__ == '__main__':

#     p = Process(target=test, args=('margo', ))

#     p.start()

#     print(f"皇帝bitten寿终正寝")

#

# # 皇帝bitten寿终正寝

# # margo总管正常活着

# # margo总管正常死亡

# # 加上p.daemon = True 让子进程成为守护进程

# if __name__ == '__main__':

#     p = Process(target=test, args=('margo', ))

#     p.daemon = True  # 将该进程设置为守护进程，这一句必须放在start()之前，否则报错

#     p.start()

#     # 守护进程一般不加 p.join，都等子进程运行完了再接着走主进程那就不是守护进程了

#     # p.join()  # 加了也能正常运行，但它失去了守护进程的意义

#     print(f"皇帝bitten寿终正寝")

#

# # 皇帝bitten寿终正寝

# 加上 time.sleep 给子进程一些运行时间（CPU运行速度超快的，1秒已经很长了）

if __name__ == '__main__':

    p = Process(target=test, args=('margo', ))

    p.daemon = True

    p.start()

    time.sleep(0.1)  # 暂停0.1 秒，给子进程一点运行时间（子进程和主进程是同步运行的）

    # 守护进程一般不加 p.join，都等子进程运行完了再接着走主进程那就不是守护进程了

    # p.join()  # 加了也能正常运行，但它失去了守护进程的意义

    print(f"皇帝bitten寿终正寝")

# margo总管正常活着

# 皇帝bitten寿终正寝

互斥锁

先看一个用并发模拟多人的抢票的案例

import bitten

from multiprocessing import Process

import time

# 查票

def search(i):

    with open('07data.txt', 'r', encoding='utf-8') as f:

        data = f.read()

    ticket_dict = bitten.loads(data)

    print(f"用户{i}查询余票为：{ticket_dict.get('ticket')}")

# 买票

def buy(i):

    with open('07data.txt', 'r', encoding='utf-8') as f:

        data = f.read()

    ticket_dict = bitten.loads(data)

    time.sleep(3)

    if ticket_dict.get('ticket') > 0:

        ticket_dict['ticket'] -= 1

        print(ticket_dict)

        with open('07data.txt', 'wt', encoding='utf-8') as f:

            bitten.dump(ticket_dict, f)

        print(f"用户{i}抢票成功")

    else:

        print("没票了！")

def run(i):

    search(i)

    buy(i)

if __name__ == '__main__':

    for i in range(4):

        p = Process(target=run, args=(i, ))

        p.start()

# {"ticket": 2}  文件数据

# 用户0查询余票为：2

# 用户1查询余票为：2

# 用户2查询余票为：2

# 用户3查询余票为：2

# {'ticket': 1}

# 用户0抢票成功

# {'ticket': 1}

# 用户1抢票成功

# {'ticket': 1}

# 用户2抢票成功

# {'ticket': 1}

# 用户3抢票成功

# 大于余票了（拿到的都是2张票），这样肯定不行

可以看出，文件中虽然只有2张票，这4个用户却都抢票成功了，并且还有一张余票，在现实生活中这种情况肯定是不允许出现的！

当多个进程操作同一份数据时会造成数据的错乱，这个时候必须加锁处理

将并发变成串行，虽然降低了效率，但是提高了数据安全

那么就尝试着用互斥锁来解决这个问题

import json

from multiprocessing import Process, Lock

import time

# 查票

def search(name):

    with open('07data.txt', 'r', encoding='utf-8') as f:

        data = f.read()

    ticket_dict = json.loads(data)

    print(f"用户{name}查询余票为：{ticket_dict.get('ticket')}")

# 买票

def buy(name):

    with open('07data.txt', 'r', encoding='utf-8') as f:

        data = f.read()

    ticket_dict = json.loads(data)

    time.sleep(1)

    if ticket_dict.get('ticket') > 0:

        ticket_dict['ticket'] -= 1

        print(ticket_dict)

        with open('07data.txt', 'wt', encoding='utf-8') as f:

            json.dump(ticket_dict, f)

        print(f"用户{name}抢票成功")

    else:

        print("没票了！")

def run(i, mutex):

    search(i)

    mutex.acquire()  # 抢锁，只要有人抢到了锁，其他人必须等待该人释放锁

    buy(i)

    mutex.release()  # 释放锁

if __name__ == '__main__':

    mutex = Lock()  # 生成了一把锁

    for i in range(4):

        p = Process(target=run, args=(i, mutex))

        p.start()

# {"ticket": 1}  文件数据

# 用户0查询余票为：1

# 用户1查询余票为：1

# 用户2查询余票为：1

# 用户3查询余票为：1

# {'ticket': 0}

# 用户0抢票成功

# 没票了！

# 没票了！

# 没票了！

# 总共1张票，被抢到一张票，票数变为0，符合预期设想

注意

锁不要轻易使用，容易造成死锁现象

只在处理数据的部分加锁，不要再全局加锁（将局部由并发变成串行）

锁必须在主进程中产生(实例化)，交给子进程去使用

(在子进程中产生那不就是多把锁了吗)

只要多进程操作同一份数据，就必须要加锁处理