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

ゝ一世哀愁。 2023-10-10 09:01 49阅读 0赞

# 多道技术 #

## 1.空间上的复用 ##

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

> 多道技术原理

![1609091-20190809103407665-1901316821.bmp][]

## 2.时间上的复用 ##

切换+保存状态

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

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

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

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

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

# 进程 #

> 程序和进程的区别

程序: 一段代码

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

进程调度

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

1.  先来先服务 （最简单的调度算法，有利于长作业，不利于短作业）
2.  短作业优先算法（短作业优先，对短作业有利，对长作业不利）
3.  时间片轮转法+多级反馈队列
    
    `时间片: 就好比将一秒等分成N多份`
    
    如果一个程序他需要更多的时间片，这个程序的执行优先级就会下降，比如A程序在运行，此时用户点击了B程序，那操作系统就会立刻停止A程序的执行，保存A程序的运行进度，然后去响应B程序
    
    ![1609091-20190809103417065-1168474757.bmp][]
4.  大概就这些？

进程三态状态转换图

![1609091-20190809104432480-289702891.bmp][]

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

（1）就绪(Ready)状态

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

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

（3）阻塞(Blocked)状态正在执行的进程，由于等待某个事件发生而无法执行时，便放弃处理机而处于阻塞状态。  
引起进程阻塞的事件可有多种，  
例如，等待I/O完成、申请缓冲区不能满足、等待信件(信号)  
input  
print  
文件操作  
sleep  
...其他的

结束阻塞态  
 input获取到值  
print输出完结果  
文件读取完毕  
 睡眠结束。

时间片的时间到了（占用CPU太久了）会自动进入就绪态，而不是阻塞，等待下一次CPU执行  
写程序的理想状态: 尽量少的进入阻塞态

![1609091-20190809104736231-1833834824.png][]

# 同步异步 #

`表示的是任务的提交方式`

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

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

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 = ('egon',)) # 创建一个进程对象 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 = ('egon',)) p.start() print('主') # 这样会报错 要把三行 放在main里面 if __name__ == '__main__': p = Prosess(target = test,args = ('egon',)) p.start() # 主进程代码等待子进程运行结束 才继续进行 print('主') # 用join if __name__ == '__main__': p = Prosess(target = test,args = ('egon',)) p.start() # 主进程代码等待子进程运行结束 才继续进行 p.join() print('主') if __name__ == '__main__': p = Prosess(target = test,args = ('egon',)) p1 = Prosess(target = test,args = ('egon',)) p2 = Prosess(target = test,args = ('egon',)) 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 = ('egon',)) p1 = Prosess(target = test,args = ('egon',)) p2 = Prosess(target = test,args = ('egon',)) 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=('egon', )) # p.start() # print(f"皇帝jason寿终正寝") # # # 皇帝jason寿终正寝 # # egon总管正常活着 # # egon总管正常死亡 # # 加上p.daemon = True 让子进程成为守护进程 # if __name__ == '__main__': # p = Process(target=test, args=('egon', )) # p.daemon = True # 将该进程设置为守护进程，这一句必须放在start()之前，否则报错 # p.start() # # 守护进程一般不加 p.join，都等子进程运行完了再接着走主进程那就不是守护进程了 # # p.join() # 加了也能正常运行，但它失去了守护进程的意义 # print(f"皇帝jason寿终正寝") # # # 皇帝jason寿终正寝 # 加上 time.sleep 给子进程一些运行时间（CPU运行速度超快的，1秒已经很长了） if __name__ == '__main__': p = Process(target=test, args=('egon', )) p.daemon = True p.start() time.sleep(0.1) # 暂停0.1 秒，给子进程一点运行时间（子进程和主进程是同步运行的） # 守护进程一般不加 p.join，都等子进程运行完了再接着走主进程那就不是守护进程了 # p.join() # 加了也能正常运行，但它失去了守护进程的意义 print(f"皇帝jason寿终正寝") # egon总管正常活着 # 皇帝jason寿终正寝

# 互斥锁 #

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

import json from multiprocessing import Process import time # 查票 def search(i): with open('07data.txt', 'r', encoding='utf-8') as f: data = f.read() ticket_dict = json.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 = json.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: json.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，符合预期设想

注意

锁不要轻易使用，容易造成死锁现象  
只在处理数据的部分加锁，不要再全局加锁（将局部由并发变成串行）  
锁必须在主进程中产生(实例化)，交给子进程去使用

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

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

转载于:https://www.cnblogs.com/PowerTips/p/11325373.html

[1609091-20190809103407665-1901316821.bmp]: https://img2018.cnblogs.com/blog/1609091/201908/1609091-20190809103407665-1901316821.bmp
[1609091-20190809103417065-1168474757.bmp]: https://img2018.cnblogs.com/blog/1609091/201908/1609091-20190809103417065-1168474757.bmp
[1609091-20190809104432480-289702891.bmp]: https://img2018.cnblogs.com/blog/1609091/201908/1609091-20190809104432480-289702891.bmp
[1609091-20190809104736231-1833834824.png]: https://img2018.cnblogs.com/blog/1609091/201908/1609091-20190809104736231-1833834824.png