创建进程
代码创建进程
创建进程的方式有哪些
1.鼠标双击桌面一个应用图标
2.代码创建
创建进程的本质:在内存中申请一块内存空间用于运行相应的程序代码
# 第一种创建进程的方式 from multiprocessing import Process import time def task(name): print('%s is running' % name) time.sleep(3) print('%s is over' % name) if __name__ == '__main__': p = Process(target=task, args=('jason',)) # 创建一个进程对象 p.start() # 告诉操作系统创建一个新的进程 print('主进程') # 创建进程的第二种方式 from multiprocessing import Process import time class MyProcess(Process): def __init__(self, username): self.username = username super().__init__() def run(self): print('你好啊 小姐姐',self.username) time.sleep(3) print('get out!!!',self.username) if __name__ == '__main__': p = MyProcess('tony') p.start() print('主进程') 该段代码就是主进程，因为用模块启动了新的子进程，所以在内存空间中新申请一块内存空间用于存放子进程代码， 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=('jason', 1)) p2 = Process(target=task, args=('tony', 2)) p3 = Process(target=task, args=('kevin', 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}') # 主进程 总耗时:3.015652894973755,在p1进行join时候，p2,p3也同时在进行，所以时间是最大的那个进程的耗时 # 如果是一个start一个join交替执行 那么总耗时就是各个任务耗时总和 需求:想让p.start()之后的代码 等待子进程全部运行结束之后再打印
- sb(sweet baby)做法:直接sleep
肯定不行 因为子进程运行的时间不可控 - 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) # 999 '''默认隔离 但是可以通过一些技术打破''' 进程对象属性和方法
进程号如何查看
windows: tasklist结果集中PID
mac: ps -ef
-
查看进程号的方法
1.1.current_process函数
from multiprocessing import Process, current_process
current_process().pid
获取进程号的用处之一就是可以通过代码的方式管理进程
windows taskkill关键字 mac/linux kill关键字 1.2.os模块
os.getpid() # 获取当前进程的进程号
os.getppid() # 获取当前进程的父进程号
- 杀死子进程
terminate() - 判断子进程是否存活
is_alive()
僵尸进程与孤儿进程
僵尸进程
为什么主进程默认需要等待子进程结束才会结束
所有的子进程在运行结束之后都会变成僵尸进程(死了没死透)
还保留着pid和一些运行过程的中的记录便于主进程查看(短时间保存)
这些信息会被主进程回收(僵尸彻底死了)
1.主进程正常结束
2.调用join方法
孤儿进程
子进程存活着 父进程意外死亡
子进程会被操作系统自动接管(儿童福利院)
守护进程
守护即死活全部参考守护的对象
对象死立刻死
from multiprocessing import Process import time def task(name): print(f'大内总管:{name}正常活着') time.sleep(3) print(f'大内总管:{name}正常死了') if __name__ == '__main__': p = Process(target=task, args=('赵公公',)) # 必须写在start前面 p.daemon = True # 将子进程设置为守护进程:主进程结束 子进程立刻结束 p.start() print('皇帝Jason寿终正寝') 互斥锁(重要)
每逢节假日抢票,手机上明明显示还有余票 但是点击购买的时候却提示已经没有票了,之后回到查询页面发现确实显示没有票了。上午10:00打开买票软件查看票数，系统给你发过来的是10:00对应的数据，只要你页面不刷新不点击下一步，那么页面数据永远展示的是10:00的
# 代码模拟抢票(有问题) import json from multiprocessing import Process import time import random # 查票 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): ''' 点击买票是需要再次查票的 因为期间其他人可能已经把票买走了 ''' # 1.查票 with open(r'ticket_data.json', 'r', encoding='utf8') as f: data = json.load(f) time.sleep(random.randint(1, 3)) # 2.判断是否还有余票 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(1, 10): p = Process(target=run, args=('用户:%s' % i,)) p.start() 当多个进程操作同一份数据的时候会造成数据的错乱！！！
这个时候需要加锁处理(互斥锁)
将并发变成串行 牺牲了效率但是保证的数据的安全
互斥锁并不能轻易使用 容易造成死锁现象
互斥锁只在处理数据的部分加锁 不能什么地方都加 严重影响程序的效率
查票可以一次性给所有人看 但是买票环节必须'排队':互斥锁
from multiprocessing import Process, Lock mutex = Lock() mutex.acquire() # 抢锁 mutex.release() # 放锁 # 我们以后在编程生涯中几乎不会自己操作锁 理解原理即可 锁相关知识
行锁:针对行数据加锁 同一时间只能一个人操作
表锁:针对表数据加锁 同一时间只能一个人操作
锁的应用范围很广 但是核心都是为了保证数据的安全!!!
乐观锁
乐观锁是对于数据冲突保持一种乐观态度，操作数据时不会对操作的数据进行加锁（这使得多个任务可以并行的对数据进行操作），只有到数据提交的时候才通过一种机制来验证数据是否存在冲突(一般实现方式是通过加版本号然后进行版本号的对比方式实现);
特点：乐观锁是一种并发类型的锁，其本身不对数据进行加锁通而是通过业务实现锁的功能，不对数据进行加锁就意味着允许多个请求同时访问数据，同时也省掉了对数据加锁和解锁的过程，这种方式因为节省了悲观锁加锁的操作，所以可以一定程度的的提高操作的性能，不过在并发非常高的情况下，会导致大量的请求冲突，冲突导致大部分操作无功而返而浪费资源，所以在高并发的场景下，乐观锁的性能却反而不如悲观锁。
乐观锁实现形式：
表A 字段
现在有两个请求同时操作表A
操作1先查询出需要检索的数据为：
操作2也查询出需要检索的数据为：
操作1把Name字段数据修改成lisi 比操作2先提交;
此时提交操作1会把之前查询到的version与现在的数据的version进行比较，版本相同则可以提交，版本不同则视为数据过期：
SQL语句:update A set Name=lisi,version=version+1 where ID=#{id} and version=#{version}
此时数据库变成了如下
那么最后操作2修改了数据来提交的时候是以操作1同样的方式，当然最后肯定不能提交成功，因为他手里的版本号和现在数据库里的版本号不匹配；
悲观锁
顾名思义，悲观锁是基于一种悲观的态度类来防止一切数据冲突，它是以一种预防的姿态在修改数据之前把数据锁住，然后再对数据进行读写，在它释放锁之前任何人都不能对其数据进行操作，直到前面一个人把锁释放后下一个人数据加锁才可对数据进行加锁，然后才可以对数据进行操作，一般数据库本身锁的机制都是基于悲观锁的机制实现的;
特点：可以完全保证数据的独占性和正确性，因为每次请求都会先对数据进行加锁， 然后进行数据操作，最后再解锁，而加锁释放锁的过程会造成消耗，所以性能不高;
手动加悲观锁：读锁LOCK tables test_db read释放锁UNLOCK TABLES;
写锁：LOCK tables test_db WRITE释放锁UNLOCK TABLES;
