from multiprocessing import Process
import time
a = 1000000000000
def task():
global a
print(id(a))
a = 0
print("子进程的",a)
if __name__ == '__main__':
print(id(a))
p = Process(target=task)
p.start() # 给操作系统发送请求后 代码继续往下运行 至于子进程 什么时候创建 什么是执行 都跟当前进程没关系
time.sleep(1)
print("自己的",a)
# 子进程中的数据修改 不会影响父进程
互斥锁的使用场景_抢票
python复制代码
import json
from multiprocessing import Process,Lock
import time
import random
"""
join和锁的区别
1.join中顺序是固定的 不公平
2.join是完全串行 而 锁可以使部分代码串行 其他代码还是并发
"""
# 查看剩余票数
def check_ticket(usr):
time.sleep(random.randint(1,3))
with open("ticket.json","r",encoding="utf-8") as f:
dic = json.loads(f.read())
print("%s查看 剩余票数:%s" % (usr,dic.get('count')))
def buy_ticket(usr):
with open("ticket.json","r",encoding="utf-8") as f:
dic = json.load(f)
if dic.get('count')> 0:
time.sleep(random.randint(1,3))
dic["count"] -= 1
with open("ticket.json", "w", encoding="utf-8") as f2:
json.dump(dic,f2)
print("%s 购票成功!" % usr)
else:
print('剩余票：',dic.get('count'))
print('Not Found of tiket!')
def task(usr,lock):
check_ticket(usr)
# time.sleep(1)
lock.acquire()
buy_ticket(usr)
lock.release()
if __name__ == '__main__':
lock = Lock()
for i in range(10):
p = Process(target=task,args=("用户%s" % i,lock))
p.start()
#p.join() # 只有第一个整个必须完毕 别人才能买 这是不公平的
父进程等待子进程结束
python复制代码
import time
from multiprocessing import Process
# def task():
# print("上传文件....")
# time.sleep(3)
# print("上传结束...")
#
#
# # [进程1,进程2,进程3]
#
# if __name__ == '__main__':
# p = Process(target=task)
# p.start()
#
# p.join() # 本质上 是提高了子进程优先级 当CPU在切换时 会优先切子进程
#
# print("上传文件成功!")
def task(num):
print("我是%s号 进程" % num)
# time.sleep(1)
print("=========")
if __name__ == '__main__':
start_time = time.time()
ps = []
for i in range(1,4):
p = Process(target=task,args=(i,))
p.start()
print("----{}".format(i))
# ps.append(p)
for p in ps:
p.join()
print(time.time()-start_time)
print("over")
process 常用属性
python复制代码
from multiprocessing import Process
import time
def task():
# time.sleep(3)
print("执行完毕!")
if __name__ == '__main__':
p = Process(target=task, name="alex")
p.start()
print(p.name)
#
# # time.sleep(1)
# print(p.is_alive())
# #
p.terminate()
# #
print(p.is_alive())
# # print(p.pid)
# p.terminate() # 终止这个进程
# print(p.pid)
# print(p.is_alive())
# p.daemon # 守护进程
"""
IPC 进程间通讯
由于进程之间内存是相互独立的 所以需要对应积极而方案 能够使得进程之间可以相互传递数据
1.使用共享文件,多个进程同时读写同一个文件
IO速度慢,传输数据大小不受限制
2.管道 是基于内存的,速度快,但是是单向的 用起来麻烦(了解)
3.申请共享内存空间,多个进程可以共享这个内存区域(重点)
速度快但是 数据量不能太大
"""
from multiprocessing import Manager,Process
#
# def task(m):
#
# print(m["num"])
#
# if __name__ == '__main__':
# # 开启了一个Manager
# with Manager() as m:
# m["num"] = 100 # 在这个空间中存储了一个num
#
# for i in range(20):
# p = Process(target=task,args=(m,))
# p.start()
#
#
from multiprocessing import Manager,Process,Lock
def work(d):
# with lock:
d['count']-=1
if __name__ == '__main__':
with Manager() as m:
dic=m.dict({'count':100}) #创建一个共享的字典
p_l=[]
for i in range(100):
p=Process(target=work,args=(dic,))
p_l.append(p)
p.start()
for p in p_l:
p.join()
print(dic)
僵尸进程
python复制代码
import time
from multiprocessing import Process
def task1():
print("子进程 run")
if __name__ == '__main__':
for i in range(10):
p = Process(target=task1)
p.start()
time.sleep(100000)