IPC生产者与消费者模型加线程
共享内存方式（IPC进程间通信）
一个进程在内存中就是对应着一块独立的内存空间
进程间通信的方式：
1.管道：只能单向通讯，数据都是二进制
2.文件：在硬盘上创建共享文件
优点：数据量无限制
缺点：传输速度慢
3.socket：编程复杂度高
4.共享内存：必须由操作系统来分配
优点;传输速度快
缺点：数据量较小
队列:
是一种特殊的数据结构，先进先出
堆栈：先进后出，像叠衣服一样
扩展：函数嵌套调用时，顺序是先进后出，也称之为函数栈
from multiprocessing import Queue q = Queue(3) # 建队列 不指定maxsize 则没有数量限制 q.put(1) q.put(2) q.put(3) print(q.get()) # 1 q.put(4) # 如果容量已经满了,在调用put时将进入阻塞状态 直到有人从队列中拿走数据有空位置 才会继续执行 print(q.get()) print(q.get()) print(q.get()) print(q.get()) # 如果队列已经空了,在调用get时将进入阻塞状态 直到有人从存储了新的数据到队列中 才会继续 #block 表示是否阻塞 默认是阻塞的 # 当设置为False 并且队列为空时 抛出异常 q.get(block=True,timeout=2) # block 表示是否阻塞 默认是阻塞的 # 当设置为False 并且队列满了时 抛出异常 # q.put("123",block=False,) # timeout 表示阻塞的超时时间 ,超过时间还是没有值或还是没位置则抛出异常 仅在block为True有效
生产者消费者模型：
生产者：生产数据的一方
消费者：处理数据的一方
出现问题的原因：就是因为生产者与消费者之间的供需不平衡
解决问题：用来双方是耦合，消费者必须等待生产者生产完毕才能够开始处理。
选择将双方分开来，一方只负责生产，另一方指负责取，需要一个共同的容器作为中间介质。
import time import random from multiprocessing import Process,Queue def task1(q): for i in range(10): time.sleep(random.randint(0, 2)) print("正在烧%s盘菜" % i) rose = "%s盘菜" % i q.put(rose) def task2(q): for i in range(10): rose = q.get() print(rose,"正在消费") time.sleep(random.randint(0, 2)) print(rose,"消费完成") if __name__ == '__main__': q = Queue() p1 = Process(target=task1, args=(q,)) p2 = Process(target=task2, args=(q,)) p1.start() p2.start()
还有问题：
生产者结束后，消费者还在循环吃，并不知道已经结束了。会在原地一致等待生产者生产数据。
解决：
用到了joinablequeue这个模块
意思：可以被join的队列
import time import random from multiprocessing import JoinableQueue, Process def make_hotdog(name, q): for i in range(5): time.sleep(random.randint(1, 3)) print("%s生产了热狗%s" % (name, i)) q.put("%s的%s号热狗" % (name, i)) def eat_hotdog(name, q): while True: hotdog = q.get() time.sleep(random.randint(1, 3)) print("%s吃掉了%s" % (name, hotdog)) # 每次处理完成一个数据，必须记录该数据 q.task_done() if __name__ == '__main__': q = JoinableQueue() p1 = Process(target=make_hotdog, args=("jerry", q)) p2 = Process(target=make_hotdog, args=("monkey", q)) p3 = Process(target=make_hotdog, args=("owen", q)) c1 = Process(target=eat_hotdog, args=("思聪", q)) c1.daemon = True c2 = Process(target=eat_hotdog, args=("健林", q)) c2.daemon = True p1.start() p2.start() p3.start() c1.start() c2.start() # 明确商家生产完毕，在明确消费者吃完了，就算结束 p1.join() print("第一家生产完毕") p2.join() print("第二家生产完毕") p3.join() print("第三家生产完毕") # 消费者吃完了 q.join() print("消费者吃完了")
多线程:
什么是线程：线程指的是一条流水线的工作过程。
线程是cpu最小的执行单位，是操作系统最小的调度单位。
对比于进程而言，进程只是一个资源单位，为线程在执行过程需要用到的数据提供资源，就好比进程是一个车间，而线程就是车间里面的流水线。
特点：
1.每个进程都会至少有一个线程，是由操作系统分配的。
2.进程内可以有多个线程
3.一个进程内的多个线程资源是共享的
4.线程的创建开销远比进程小的多。
主线程与子线程的区别：
线程之间是平等的
2.主线程由操作系统分配，子线程由程序开启
3.主线程的代码执行完毕，主线程并没有结束而是会等其他子线程代码运行完毕后，线程才会结束。
开启线程的2种方式（和进程一样的，只是不用写在__main__里面
# 方式一 直接实例化Thread类 from threading import Thread def task(): print("子线程 is running") t = Thread(target=task) t.start() # 执行的顺序不固定，一般来说，开启子线程的速度远远高于继续执行主线程的速度 print("主线程 is runnning") # # # 方式二：自定义类继承thread类 class MyThread(Thread): def run(self): print("子线程 is running") t = MyThread() t.start() print("主线程 is running")
同一个进程之间数据共享
import time,os from threading import Thread x = 100 def task(): global x x = 10 print("线程",os.getpid()) # 与主线程的pid相同 t = Thread(target=task) t.start() # 主线程等待子线程执行完毕 time.sleep(3) print(x) # 10 print("主线程",os.getpid())
守护线程：
与守护进程的区别就是，守护进程在被守护进程结束后会立即结束并不会等其他非守护进程，
而守护线程则是会等待其他非守护线程结束而结束，当然2个都可以提前结束、
import time from threading import Thread def task1(): print("子进程1 is running") time.sleep(3) print("子进程1 is over") def task2(): print("子进程2 is running") time.sleep(2) print("子进程2 is over") t1 = Thread(target=task1) t2 = Thread(target=task2) t1.daemon = True t1.start() t2.start() print("主进程 Game Over")
互斥锁：
多线程最主要的特征之一就是：一个进程内的多个线程资源共享。
资源共享就是带来竞争问题，所以要加锁
from threading import Lock, enumerate,Thread import time num = 10 lock = Lock() def task(): for i in range(10): t = Thread(target=tas global num lock.acquire() a = num time.sleep(0.1) num = a - 1 lock.release()k) t.start() for t in enumerate()[1:]: t.join() print(num)
