线程

进程间通信

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())  # 当队列中没有数据,程序阻塞,直到队列中有数据

进程间通信IPC机制

from multiprocessing import Process,Queue
def producer(q):
    q.put('hello')
def consumer(q):
    print(q.get())
if __name__ == '__main__':
    q = Queue()
    p = Process(target=producer,args=(q,))
    p1 = Process(target=consumer,args=(q,))
    p.start()
    p1.start()

生产者消费者模型

　　JoinableQueue 能够被join的q,    q.task_done()  告诉队列数据被取出    q.join()  等待队列数据完全被取完

from multiprocessing import Process,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()
        print('%s吃了%s'%(name,data))
        time.sleep(random.random())
        q.task_done()   #告诉队列从中取出一个数据,并且处理完毕了
if __name__ == '__main__':
    q = JoinableQueue()
    p = Process(target=producer,args=('egon','馒头',q))
    p1 = Process(target=producer,args=('tank','生蚝',q))
    p2 = Process(target=consumer,args=('jason',q))
    p3 = Process(target=consumer,args=('alex',q))
    p.start()
    p1.start()
    p2.daemon = True
    p3.daemon = True
    p2.start()
    p3.start()
    p.join()
    p1.join()
    q.join()   # 等到队列中数据全部取出

什么是线程
    进程线程其实都是虚拟单位,都是用来帮助我们形象的描述某种事物

　　进程:资源单位
       线程:执行单位

　　　　将内存比如成工厂  那么进程就相当于是工厂里面的车间   而你的线程就相当于是车间里面的流水线
    ps:每个进程都自带一个线程,线程才是真正的执行单位,进程只是在线程运行过程中
    提供代码运行所需要的资源

为什么要有线程
    开进程
        1.申请内存空间  耗资源
        2."拷贝代码"    耗资源

　开线程
     　一个进程内可以起多个线程,并且线程与线程之间数据是共享的
        ps:开启线程的开销要远远小于开启进程的开销

创建线程的两种方式

方式一
from threading import Thread
import time
def tast(name):
    print('%s'%name)
    time.sleep(1)
    print('gun')
t = Thread(target=tast,args=('egon',))  # 开线程不需要在__main__代码块内 但是习惯性的还是写在__main__代码块内
t.start()  # 告诉操作系统开辟一个线程  线程的开销远远小于进程,小的代码执行完 线程就已经开启了
print('hi')

方式二
from threading import Thread
import time
class MyThread(Thread):
    def __init__(self,name):
        super().__init__()
        self.name = name
    def run(self):
        print('%s'%self.name)
        time.sleep(1)
        print('gun')
t = MyThread('egon')
t.start()
print('hi')

线程对象及其它方法

from threading import Thread,current_thread,active_count
import  time
import os
def test(name,i):
    print('%s'%name)
    print('子',current_thread().name)
    print('子',os.getpid())
    time.sleep(i)
    print('hi')
t = Thread(target=test,args=('egon',1))
t1 = Thread(target=test,args=('tank',2))
t.start()
t1.start()
t.join()
print('进程数',active_count())
print('主')
print('主',current_thread().name)
print('主',os.getpid())

守护线程

from threading import Thread,current_thread
import time
def test(i):
    print(current_thread().name)
    time.sleep(i)
    print('gg')
for i in range(3):
    t = Thread(target=test,args=('i'),)
    t.daemon = True
    t.start()
    print('主')

线程间通信

from threading import Thread
money = 100
def test():
    global money
    money = 999
t = Thread(target=test)
t.start()
t.join()
print(money)

互斥锁

from threading import Thread,Lock
import time
n = 100
def test(mutex):
    global n
　　 tmp = n
    mutex.acquire()
    n = tmp - 1
    mutex.release()
mutex = Lock()
l_list = []
for i in range(10):
    t = Thread(target=test,args=(mutex,))
    t.start()
    l_list.append(t)
for t in l_list:
    t.join()
print(n)