1.进程间的通信
""" 队列:先进先出 堆栈:先进后出 """ from mulitprocessing import Queue q = Queue(5) # 括号内可以传参数 表示的是这个队列的最大存储数 q.put(1) q.put(2) print(q.full()) # 判断队列是否满了 q.put(3) q.put(4) q.put(5) print(q.full()) q.put(6) # 当队列满了之后 再放入数据 不会报错 会原地等待 直到队列中有数据被取走(阻塞态) print(q.get()) print(q.get()) print(q.empty()) # 判断队列是否为空 print(q.get()) print(q.get()) print(q.get()) print(q.empty()) print(q.get_nowait()) # 取值 没有值不等待直接报错 print(q.get()) # 当队列中的数据被取完之后,再次获取,程序会阻塞,直到有人往队列里放入值 """ full get_nowait empty 都不适用于多进程的情况 """
进程间通信IPC机制
from multiprocessing import Process,Queue def producer(q): q.put('hello baby') def consumer(q): print(q.get()) if __name__ == '__main__': q = Queue() p = Process(target=producer,args=(q,)) c = Process(target=consumer,args=(q,)) p.start() c.start() """ 子进程放数据 主进程获取数据 两个子进程相互放 取数据 """
生产者消费者模型
from multiprocessing import Process,JoinableQueue import time import random def producer(name,food,q): for i in range(10): data = '%s生产的%s%s'%(name,food,i) time.sleep(random.random()) print(data) q.put(data) def consumer(name,q): while True: data = q.get() print(' 33[31m%s吃了%s 33[0m'%(name,data)) time.sleep(random.random()) q.task_done() # 告诉队列你已经从队列中取出一个数据 并且处理完毕了 if __name__ == '__main__': q = JoinableQueue() p1 = Process(target=producer,args=('zmm','鱼',q)) p2 = Process(target=producer,args=('yzy','肉',q)) c1 = Process(target=consumer,args=('czh',q)) c2 = Process(target=consumer,args=('lc',q)) c1.daemon = True c2.daemon = True p1.start() p2.start() c1.start() c2.start() p1.join() p2.join() q.join() # 等到队列中数据全部取出
线程
什么是线程
进程线程其实都是虚拟单位,都是用来帮助我们形象的描述某种事物
进程:资源单位
线程:执行单位
将内存比作工厂,那么进程就相当于工厂里的车间,线程就相当于车间里的流水线
ps: 每个进程都自带一个线程,线程才是真正的执行单位,进程只是在线程运行过程中提供代码运行所需要的资源
为什么要有线程
开进程
1.申请内存空间 耗资源
2."拷贝代码" 耗资源
开线程
一个进程内可以起多个线程,并且线程与线程之间数据是共享的
ps:开启线程的开销要远远小于开启进程的开销
创建线程的两种方式
import time from threading import Thread def task(name): print(' 33[32m%s is running 33[0m'%name) time.sleep(1) print('%s is over'%name) # 开线程不需要在__main__代码块内 但是习惯性的还是写在__main__代码块内 t = Thread(target=task,args=('zmm',)) t.start() # 告诉操作系统开辟一个线程 线程的开销远远小于进程 # 小的代码执行完 线程就已经开启了 print('主')
from threading import Thread import time class MyThread(Thread): def __init__(self,name): super().__init__() self.name = name def run(self): print('%s is running'%self.name) time.sleep(1) print('%s is over'%self.name) t = MyThread('zmm') t.start() print('主')
内存数据的共享问题
from threading import Thread money = 666 def task(): global money money = 100 t = Thread(target=task) t.start() print(money) # 100
守护线程
from threading import Thread,current_thread import time def task(i) print(current_thread().name) time.sleep(1) print('GG') t1 = Thread(target=task,args=(1,)) t2 = Thread(target=task,args=(2,)) t3 = Thread(target=task,args=(3,)) # t1.daemon = True # t2.daemon = True t3.daemon = True t1.start() t2.start() t3.start() print('zhu') """ Thread-1 Thread-2 Thread-3 zhu GG GG """ """ 主线程的结束也就意味着进程的结束 主线程必须等待其他非守护线程的结束才能结束 (意味着线程在运行的时候需要使用进程中的资源,而主线程一旦结束了,资源也就销毁了) """
线程对象及其他方法
from threading import Thread,current_thread,active_count import time import os def task(name,i) print('%s is running'%name) print('子current_thread:',current_thread().name) print('子',os.getpid()) time.sleep(i) print('%s is over'%name) t1 = Thread(target=task,args=('zmm',1)) t2 = Thread(target=task,args=('yzy',2)) t1.start() t2.start() ti.join() print('当前正在活跃的线程数:',active_count()) print('主') print('主',os.getpid()) print('主current_thread:',current_thread().name)
互斥锁
from threading import Thread,Lock import time n = 100 def task(mutex): global n mutex.acquire() num = n time.sleep(0.1) n = num - 1 mutex.release() t_list = [] mutex = Lock() for i in range(100): t = Thread(target=task,args=(mutex,)) t.start() t_list.append(t) for t in t_list: t.join() print(n)
小例子
from threading import Thread import time def foo(): print(123) time.sleep(1) print("end123") def bar(): print(456) time.sleep(3) print("end456") if __name__ == '__main__': t1=Thread(target=foo) t2=Thread(target=bar) t1.daemon=True t1.start() t2.start() print("main-------") """ 123 456 main------- end123 end456 """