进程和线程
队列
进程彼此之间相互隔离，要实现进程间通信（IPC），multiprocessing模块支持两种形式：队列和管道，这两种方式都是使用消息传递的。
队列：先进先出
堆栈：先进后出
from multiprocessing 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.get()) print(q.empty()) #判断队列中的数据是否取完，返回的是布尔值 print(q.get()) print(q.get()) print(q.empty()) # print(q.get_nowait()) #取值，没有值不等待直接报错 # print(q.get()) #当队列中的数据被取完之后，再次获取，程序会阻塞 ''' full get_nowait empty 都不适用于多进程的情况 '''
1 q.put方法用以插入数据到队列中，put方法还有两个可选参数：blocked和timeout。如果blocked为True（默认值），并且timeout为正值，该方法会阻塞timeout指定的时间，直到该队列有剩余的空间。如果超时，会抛出Queue.Full异常。如果blocked为False，但该Queue已满，会立即抛出Queue.Full异常。 2 q.get方法可以从队列读取并且删除一个元素。同样，get方法有两个可选参数：blocked和timeout。如果blocked为True（默认值），并且timeout为正值，那么在等待时间内没有取到任何元素，会抛出Queue.Empty异常。如果blocked为False，有两种情况存在，如果Queue有一个值可用，则立即返回该值，否则，如果队列为空，则立即抛出Queue.Empty异常. 3 4 q.get_nowait():同q.get(False) 5 q.put_nowait():同q.put(False) 6 7 q.empty():调用此方法时q为空则返回True，该结果不可靠，比如在返回True的过程中，如果队列中又加入了项目。 8 q.full()：调用此方法时q已满则返回True，该结果不可靠，比如在返回True的过程中，如果队列中的项目被取走。 9 q.qsize():返回队列中目前项目的正确数量，结果也不可靠，理由同q.empty()和q.full()一样
其他方法
1 q.cancel_join_thread():不会在进程退出时自动连接后台线程。可以防止join_thread()方法阻塞 2 q.close():关闭队列，防止队列中加入更多数据。调用此方法，后台线程将继续写入那些已经入队列但尚未写入的数据，但将在此方法完成时马上关闭。如果q被垃圾收集，将调用此方法。关闭队列不会在队列使用者中产生任何类型的数据结束信号或异常。例如，如果某个使用者正在被阻塞在get()操作上，关闭生产者中的队列不会导致get()方法返回错误。 3 q.join_thread()：连接队列的后台线程。此方法用于在调用q.close()方法之后，等待所有队列项被消耗。默认情况下，此方法由不是q的原始创建者的所有进程调用。调用q.cancel_join_thread方法可以禁止这种行为
进程间通信IPC机制
子进程放数据，主进程获取数据，两个子进程相互放、取数据
from multiprocessing import Process,Queue
def producer(q): q.put('hello world!') 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,Queue,JoinableQueue
import random
import time
def producer(name, food, q):
for i in range(10):
data = '%s生产了%s%s'%(name, food, i)
time.sleep(random.random())
q.put(data)
print(data)
def consumer(name,q):
while True:
data = q.get()
if data == None:break
print('%s吃了%s'%(name,data))
time.sleep(random.random())
q.task_done() #告诉队列你已经从队列中取出了一个数据，并且处理完毕了
if __name__ == '__main__':
q = JoinableQueue()
p = Process(target=producer, args=('大厨Jason','包子', q))
p1 = Process(target=producer, args=('配菜tank', '小龙虾', q))
c = Process(target=consumer, args=('猪八戒', q))
c1 = Process(target=consumer, args=('jerry', q))
p.start()
p1.start()
c.daemon = True
c1.daemon = True
c.start()
c1.start()
p.join()
p1.join()
#JoinableQueue([maxsize])：这就像是一个Queue对象，但队列允许项目的使用者通知生成者项目已经被成功处理。通知进程是使用共享的信号和条件变量来实现的。
#参数介绍：
maxsize是队列中允许最大项数，省略则无大小限制。
#方法介绍：
JoinableQueue的实例p除了与Queue对象相同的方法之外还具有：
q.task_done()：使用者使用此方法发出信号，表示q.get()的返回项目已经被处理。如果调用此方法的次数大于从队列中删除项目的数量，将引发ValueError异常
q.join():生产者调用此方法进行阻塞，直到队列中所有的项目均被处理。阻塞将持续到队列中的每个项目均调用q.task_done（）方法为止
线程
进程线程其实都是虚拟单位，都是用来帮助我们形象的描述某种食物
进程：资源单位
线程：执行单位
在传统操作系统中，每个进程有一个地址空间，而且默认就有一个控制线程
线程顾名思义，就是一条流水线工作的过程，一条流水线必须属于一个车间，一个车间的工作过程是一个进程
车间负责把资源整合到一起，是一个资源单位，而一个车间内至少有一个流水线
流水线的工作需要电源，电源就相当于cpu
所以，进程只是用来把资源集中到一起（进程只是一个资源单位，或者说资源集合），而线程才是cpu上的执行单位。
多线程（即多个控制线程）的概念是，在一个进程中存在多个控制线程，多个控制线程共享该进程的地址空间，相当于一个车间内有多条流水线，都共用一个车间的资源。
例如，北京地铁与上海地铁是不同的进程，而北京地铁里的13号线是一个线程，北京地铁所有的线路共享北京地铁所有的资源，比如所有的乘客可以被所有线路拉。
为什么要有线程
进程：1.申请内存空间，耗资源。 2.“拷贝代码”，耗资源
线程：一个进程内可以起多个线程，并且线程与线程之间数据是共享的
开启线程的开销要远远小于开启进程的开销
进程之间是竞争关系，线程之间是协作关系。
为什么要用多线程
多线程指的是，在一个进程中开启多个线程，简单的讲：如果多个任务共用一块地址空间，那么必须在一个进程内开启多个线程。详细的讲分为4点：
1. 多线程共享一个进程的地址空间
2. 线程比进程更轻量级，线程比进程更容易创建可撤销，在许多操作系统中，创建一个线程比创建一个进程要快10-100倍，在有大量线程需要动态和快速修改时，这一特性很有用
3. 若多个线程都是cpu密集型的，那么并不能获得性能上的增强，但是如果存在大量的计算和大量的I/O处理，拥有多个线程允许这些活动彼此重叠运行，从而会加快程序执行的速度。
4. 在多cpu系统中，为了最大限度的利用多核，可以开启多个线程，比开进程开销要小的多。（这一条并不适用于python）
from threading import Thread
import time
def task(name):
print('%s is running'%name)
time.sleep(3)
print('%s is over'%name)
#开线程不需要在__main__代码块内，但是习惯性的还是写在__main__代码块内
t = Thread(target=task,args=('egon',))
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(3)
print('%s is over'%self.name)
t = MyThread('egon')
t.start()
print('主')
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.getegid())
time.sleep(i)
print('%s is over'%name)
# 开线程不需要在__main__代码块内，但是习惯性的还是写在__main__代码块内
t = Thread(target=task,args=('egon',1))
t1 = Thread(target=task,args=('jason', 2))
t.start() #告诉操作系统开辟一个线程，线程的开销远远小于进程
t1.start() #告诉操作系统开辟一个线程，线程的开销远远小于进程
t1.join() #主线程等待了线程运行完毕
print('当前正在活跃的线程数', active_count())
print('主')
# print('主current_thread:', current_thread().name)
# print('主', os.getegid())
主线程的结束也就意味着进程的结束
主线程必须等待其他非守护线程的结束才能结束
(意味子线程在运行的时候需要使用进程中的资源,而主线程一旦结束了资源也就销毁了)
from threading import Thread,current_thread
import time
def task(i):
print(current_thread().name)
time.sleep(i)
print('GG')
t = Thread(target=task,args=(1,))
t.daemon = True
t.start()
print('主')
#主线程运行结束之后需要等待子线程结束才能结束呢？
线程间通信
from threading import Thread
money = 666
def task():
global money
money = 999
t = Thread(target=task)
t.start()
t.join()
print(money)
互斥锁
from threading import Thread,Lock
import time
n = 100
def task(mutex):
global n
mutex.acquire()
tmp = n
time.sleep(0.1)
n = tmp - 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)
