线程相关（一）

一.进程间通信

1.进程间通信之队列：先进先出

from multiprocessing import Queue

q = Queue(5)  #参数表示的是队列的最大存储数
#往队列中添加数据
q.put(1)
q.put(2)
print(q.full())  #q.full()是判断队列是否满了
q.put(3）
q.put(4)
q.put(5)
print(q.full())

#q.put(6) 这个时候 队列满了  会原地等待 直到队列中有数据出来 才会执行#（阻塞态）

print(q.get()) #从队列中取数据  先进先出   如果队列中没有数据  会等待程#序会进入阻塞，直到队列中有数据放入
print(q.get_nowait()) #取值 没有值不等待直接报错
#full  get_nowait 都不适用于多进程的情况

2.进程间通信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,))
    p.start()
    c = Process(target = consumer,args = (q,))
    c.start()
    

3.生产者与消费者模型****

生产者：生产制造数据的

消费者：消费处理数据的

下面举个做包子与买包子的例子：

from multiprocessing import Process, Queue,JoinableQueue
import random
import time

def producer(name,food,q):
    for i in range(5):
        data = '%s生产了%s'%(name,food)
        time.sleep()
        q.put(data)
        print(data)

def consumer(name,q):
    while True:
        data = q.get()
        if not data:
            break
        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))
    c = Process(target = consumer,args = ('jerry',q))
    c1 = Process(target = consumer,args = ('jason',q))
    p.start()
    p1.start()
    c.daemon = True
    c1.daemon = True
    c.start()
    c1.start()
    p.join()
    p1.join()

    q.join()  #等待队列里面数据全部取出

二.线程

1.什么是线程?

　　进程线程其实都是虚拟单位，都是用来帮助我们形象的描述具体事物

　　进程:资源单位

　　线程：执行单位

　　将内存比喻成工厂，那么进程就相当于工厂里的车间

　　而你的线程就相当于是车间里面的流水线

　　Ps:每个进程都自带一个线程， 线程才是真正的执行单位，进程只是再线程运行过程中

　　提供代码运行所需要的资源

2.为什么有线程

　　开进程

　　　　1.申请内存空间　　耗资源

　　　　2.拷贝代码　　耗资源

　　开线程

　　　　一个进程内可以起多个线程，并且线程与线程之间数据是共享的

　　　　Ps:开启的线程的开销要远远小于开启进程的开销

3.创建线程的两种方式

from threading  import Thread
import time
def task(name):
    print('%s is running' %name)
    time.sleep(3)
    print('%s is over'%name)

t = Thread(target = task,args('egon',))
t.start()
print('主')

from threading import Thread
import time

class MyThread():
    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('主')

4.线程对象及其他方法

from threading import Thread,current_thread,active_count
import os
import time

def test(name):
    print('%s is running' %name)
    print('子 current_thread',current_thread().name)
    print('子',os.getpid())
    time.sleep(3)
    print('%s is over'%name)

t = Thread(target = test,args =('egon'))
t1 = Thread(target = test,args =('egon1'))
t.start()
t1.start()

t.join()
t1.join()  #主线程等待子线程运行完毕

print('当前正在活跃的线程数:',active_count())
print('主')

5.线程间通信

线程间数据是共享的

from threading import Thread

n = 666

def test():
    global n
    n = 999
  
t = Thread(target = test)
t.start()
t.join()
print(n)  #结果是 999

线程互斥锁

from threading import Thread,Lock
import time

n = 100

def test(mutex):
    global n
    mutex.acquire()
    tmp = n 
   
    n = tmp-1
    mutex.release()

t_list = []
mutex = Lock()
for i in range(100):
    t = Thread(target = test,args=(mutex,))
    t.start()
    t_list.append(t)

for t in t_list:
    t.join()

print(n)

6.守护线程

主线程的结束意味着这进程的结束

主线程要等待所有非守护子线程结束才能结束

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
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