进程互斥锁:
让并发变成串行, 牺牲了执行效率, 保证了数据安全.在程序并发执行时,需要修改数据时使用.
队列
队列:先进先出
相当于内存中产生一个队列空间,先进先出,
可以存放多个数据,但数据的顺序是由先进去的排在前面.
堆栈
先进后出,后进后出。
from multiprocessing import Queue
# 调用队列类,实例化队列对象 q
q = Queue(5) # 若传参队列中可以存放5个数据
# q1 = Queue() # 若不传参,队列中可以存放无限大的数据,前提硬件能更得上
# put添加数据,若队列中的数据满了,则卡住
q.put(1)
print('进入数据1')
q.put(2)
print('进入数据2')
q.put(3)
print('进入数据3')
# 查看队列是否满了
print(q.full()) # True
# 添加数据,若队列满了,则会报错
# q.put_nowait(6)
# q.get(): 获取的数据遵循 "先进先出",若队列中无数据可取,也会卡住
print(q.get())
print(q.get())
print(q.get())
# print(q.get())
# get_nowait: 获取数据,队列中若没有,则会报错
# print(q.get_nowait())
进入数据1
进入数据2
进入数据3
False
1
2
3
True
进入数据6
IPC进程间通信
IPC(进程间通信):进程间数据是相反隔离的,若想实现进程间通信可以使用队列。
from multiprocessing import Process
from multiprocessing 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()
print('主')
主
进程1开始添加数据到队列中..
进程2从队列中获取数据数据hello
生产者与消费者
生产者:
生产数据的
消费者:
使用数据的
生活中:
比如-->:卖油条,一边生产,一边卖,供需不平衡。
程序中:
通过队列,生产者把数据添加队列中,消费者从队列中获取数据。
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=('tank', '油条', q))
p2 = Process(target=producer, args=('华农兄弟', '竹鼠', q))
# 生产消费者
c1 = Process(target=consumer, args=('egon', q))
c2 = Process(target=consumer, args=('jason', q))
p1.start()
p2.start()
c1.daemon = True
c2.daemon = True
c1.start()
c2.start()
p2.join()
print('主')
线程
1.什么是线程?
线程与进程都是虚拟单位。
目的:为了更好的描述某种事物。
进程:资源单位
线程:执行单位
开启一个进程,一定会有一个线程,线程才是真正执行者。
2.为什么要使用线程?
节省内存资源
开启进程:
1.开辟一个名称空间,买开启一个进程都会占用一份内存资源。
2.会自带一个线程。
开启线程
1.一个进程可以开启多个线程
2.线程的开销远小于进程。
注意:线程不能实现并行,线程只能实现并发,进程可以实现并行
比喻:主进程就像一个工厂,子进程就像一个工厂车间,线程就像车间内的流水线。
from threading import Thread
mport time
# 开启线程方式2:
class MyThread(Thread):
def run(self):
print('线程开启')
time.sleep(1)
print('线程结束')
t = MyThread()
t.start()
线程开启
线程结束
线程对象的属性
from threading import Thread
from threading import current_thread
import time
def task():
print(f'线程开启{current_thread().name}')
time.sleep(3)
print(f'线程结束{current_thread().name}')
if __name__ == '__main__':
t = Thread(target=task)
t.daemon = True
t.start()
线程开启Thread-1
主
先行互斥锁
线程之间数据是共享的.