网络编程
- 代码创建进程
- join方法
- 进程间数据默认隔离
- 进程对象相关属性和方法
- 僵尸进程与孤儿进程
- 守护进程
- 互斥锁
代码创建进程
创建进程的本质：在内存中申请一块内存空间用于运行相应的程序代码
第一种方法（类的对象）
1.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('主进程')
输出结果：
主进程
jason is running
jason is over
第二种方法（类的继承）：
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('主进程')
输出结果：
主进程
你好啊 小姐姐，tony
get out!!!,tony
以上两种方法都能创建进程，但是要注意的一点是不同的操作系统创建进程的要求不一样
在windows中创建进程是以导入模块的方式进行 所以创建进程的代码必须写在__main__子代码中
否则会直接报错 因为在无限制创建进程； 在linux和mac中创建进程是直接拷贝一份源代码然后执行 不需要写在__main__子代码中。
进程实现并发
# 服务端：
import socket
from multiprocessing import Process
def get_server():
server = socket.socket()
server.bind(('127.0.0.1', 8080))
server.listen(5)
return server
# 将服务客户端的代码封装成函数(通信代码)
def talk(sock):
while True:
data = sock.recv(1024)
print(data.decode('utf8'))
sock.send(data.upper())
if __name__ == '__main__':
server = get_server()
while True:
sock, addr = server.accept()
p = Process(target=talk, args=(sock, ))
p.start()
封装一个get_server，这个创建进程就不会反复执行里面的代码，从而避免报地址只允许使用一次的错误。
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
# 如果是一个start一个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)
进程对象属性和方法
# 进程号如何查看
windows: tasklist结果集中PID
mac: ps -ef
1.查看进程号的方法
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() # 获取当前进程的父进程号
2.杀死子进程
terminate()
3.判断子进程是否存活
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寿终正寝')
互斥锁
# 代码模拟抢票(有问题)
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() # 放锁
ps:我们以后在编程生涯中几乎不会自己操作锁 理解原理即可
"""
锁相关知识
行锁:针对行数据加锁 同一时间只能一个人操作
表锁:针对表数据加锁 同一时间只能一个人操作
乐观锁：总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下，在此期间有没有别人去更新这个数据，可以使用版本号机制和CAS算法实现。乐观锁适用于多读的应用类型，这样可以提高吞吐量。优点是：乐观锁是一种并发类型的锁，其本身并不对数据进行加锁，而是通循环重试CAS进而实现锁的功能，其不对数据进行加锁就意味着允许多个线程同时读取（因为根本没有加锁操作）数据，但是只有一个线程可以成功更新数据，并导致其他要更新数据的线程回滚重试，这种方式大大的提高了数据操作的性能
悲观锁：总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁（共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程）。优点是：可以完全保证数据的独占性和正确性。缺点是：因为每次请求都会先对数据进行加锁， 然后进行数据操作，最后再解锁，而加锁释放锁的过程会造成消耗，所以性能不高
锁的应用范围很广 但是核心都是为了保证数据的安全!!!
