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，符合预期设想

注意

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

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

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

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

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

巴特西

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

多道技术

1.空间上的复用

2.时间上的复用

进程

同步异步

阻塞非阻塞

创建进程的两种方式

守护进程

互斥锁

最新文章

热门文章

巴特西

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

多道技术

1.空间上的复用

2.时间上的复用

进程

同步异步

阻塞非阻塞

创建进程的两种方式

守护进程

互斥锁

最新文章

热门文章

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