python day29
进程互斥锁
枷锁可以保证多个进程修改同一块数据时,同一时间只能有一个任务可以进行修改,即串行的修改,虽然牺牲了执行效率,保证了数据安全
在程序并发执行时,需要修改数据时使用
'''
模拟抢票软件需求:
并发查票与抢票
1.查看余票
2.开始抢票
进程互斥锁:
让并发变成串行, 牺牲了执行效率, 保证了数据安全.
在程序并发执行时,需要修改数据时使用.
'''
import json
from multiprocessing import Process
from multiprocessing import Lock
def search(user):
with open('data.txt','r',encoding='utf8') as f:
dic = json.load(f)
print(f'{user}查询余票,还剩余{dic["ticket_num"]}')
def buy(user):
with open('data.txt','r',encoding='utf8') as f:
dic = json.load(f)
if dic['ticket_num'] > 0:
dic['ticket_num'] -= 1
with open('data.txt','w',encoding='utf8') as f:
json.dump(dic,f)
f.flush()
print(f'{user}抢票成功!')
else:
print('没有票了!')
def run(user,mutex):
search(user)
mutex.acquire()
buy(user)
mutex.release()
if __name__ == '__main__':
mutex = Lock()
for i in range(10):
p = Process(target=run,args=(f'用户{i}', mutex))
p.start()进程间通信
因为进程之间的数据是相互隔离的,要实现进程间的通信(IPC机制),就必须借助于其他的技术,比如multiprocessing模块中的:
队列
创建共享的进程队列,Queue是多进程安全的队列,可以使用Queue实现多进程之间的数据传递
队列可以存放多个数据,但是数据要遵循先进先出的顺序
'''
队列:先进先出
相当于内存中产生一个队列空间
堆栈: 先进后出
'''
from muliprocess import Queue
#调用队列类,实例化队列对象q
q = Queue(3)
#put添加数据,若队列的数据满了,则卡住
q.put(1)
print('数据1')
q.put(2)
print('数据2')
q.put(3)
print('数据3')
#查看队列是否满了
print(q.full()) #True
#q.get():获取的数据遵循'先进先出',若队列中无数据可取,也会卡住
print(q.get())
print(q.get())
print(q.get())
#print(q.get())
#get_nowait():也是用来获取数据,队列中若没有,则会报错
#print(q.get_nowait())
#判断队列是否为空
print(q.empty())
q.put(4)
q.pu_nowait(5)'''
IPC(进程间通信):
进程间数据是相互隔离的,若想实现进程间通信,可以利用队列.
'''
from muliprocessing import Process
from muliprocessing import Queue
def test1(q):
data = '数据hello'
q.put(data)
print('进程1开始添加数据到队列中..')
def test2(q):
data = q.get()
print(f'进程2从队列中获取数据{data}')
if __name__ == '__main__':
q = Queue()
p1 = Process(target = test1,args = (q,))
p2 = Process(target = test2,args = (q,))
p1.start()
p2.start()生产者消费者模型
生产者 ----> 产生数据
消费者 ----> 使用数据
from multiprocessing import Queue, Process
import time
# 生产者
def producer(name, food, q):
for i in range(9):
data = food, i
msg = f'用户{name}开始制作{data}'
print(msg)
q.put(data)
time.sleep(0.1)
# 消费者
def consumer(name, q):
while True:
data = q.get()
if not data:
break
print(f'用户{name}开始吃{data}')
if __name__ == '__main__':
q = Queue()
p1 = Process(target=producer, args=('user_1', '鸡腿', q))
p2 = Process(target=producer, args=('user_2', '薯条', q))
c1 = Process(target=consumer, args=('jack', q))
c2 = Process(target=consumer, args=('rose', q))
p1.start()
p2.start()
c1.start()
c2.start()
p2.join()
print('主程序结束!')线程
什么是线程
在操作系统中,每个进程都有一个地址空间,而且默认就有一个控制线程
线程与进程都是虚拟单位,目的是为了更好的描述某种事物,所以,进程只是用来把资源集中到一起,二线程才是cpu上的执行单位
进程:资源单位
扫描二维码关注公众号，回复：
7544773 查看本文章
线程:执行单位
开启一个进程,一定会有一个线程,线程才是真正的执行者
为什么要是用线程
节省内存资源
开启进程
1. 开辟一个名称空间,每开启一个进程都会占用一份内存资源
2. 会自带一个线程开启线程
1. 一个进程可以开启多个线程
2. 线程的开销远小于进程attention : 线程不能实现并行,线程只能实现并发,进程可以实现并行
开启线程的方式
方式一
from threading import Thread
import time
def task():
print('线程开启')
time.sleep(1)
print('线程结束')
if __name__ == '__main__':
#调用Thread线程类实例化得到线程对象
t = Thread(target = task)
t.start()方式二
class MyThread(Thread):
def run(self):
print('线程开启')
time.sleep(1)
print('线程结束')
if __name__ == '__main__':
t = MyThread()
t.start()线程对象的属性
t.isAlive 判断线程是否还存活
t.daemon 守护线程
线程之间的数据是共享的线程互斥锁
from threading import Thread,Lock
import time
mutex = Lock()
n = 100
def task(i):
print(f'线程{i}启动..')
global n
mutex.acquire()
temp = n
time.sleep(0.1)
n = temp - 1
print(n)
mutex.release()
if __name__ == '__main__':
t_list = []
for i in range(10):
t = Tread(target = task,args(i,))
t_list.append(t)
t.start()
for i in t_list:
t.join()
print(n)