线程

1.queue队列

2.进程间通讯IPC机制

3.什么是线程（理论）

4.开启线程的俩种方式

5.生产者消费者模型

6.线程的其他方法

7.线程间是可以通讯的

8.守护线程

9.互斥锁

一.queue队列

 1.队列：先进先出

 2.堆栈：先进后出

# get和put最好是一一对应，而且不要超过你传入的最大值，不会回进入阻塞态
from multiprocessing import Queue

q = Queue(5)# 括号内可以放参数，表示的是这个队列最大存储量

q.put('q')
q.put('w')
q.put('e')
q.put('r')
q.put('t')
q.put('t')# 如果队列被放满了，还继续往队列里面添加值，程序不会报错，会原地等待，直到有人取走值


print(q.get())
print(q.get())
print(q.get())
print(q.get())
print(q.get())# 如果没有值取空了，在取的话，程序会进入阻塞状态，知道有人继续往队列中添加值


'''
还有几种方法（但这几种方法都不适用多进程的情况）
q.full()判断队列是否满了
print(q.empty())判断队列中的数据数据是否取完了
print(q.get_nowait())取值，没有值不等待直接报错
'''

二.进程间通讯IPC机制

进程间通讯
​通讯指的就是交换数据
进程之间内存是相互隔离的,当一个进程想要把数据给另外一个进程,就需要考虑IPC
用队列可以测验出进程间是可以通过一些方法进行通讯的

from multiprocessing import Process,Queue

def qwe(q):
    q.put('hello ')


def zxc(q):
    print(q.get(q))

if __name__ == '__main__':
    q = Queue()
    p = Process(target=qwe,args=(q,))
    p1 = Process(target=zxc,args=(q,))
    p.start()
    p1.start()

三.什么是线程

什么是线程：
    线程是操作系统最小的运算调度单位，被包含在进程中，一个线程就是一个固定的执行流程

线程和进程的关系：
    线程不能单独存在，必须存在于进程中，
进程是一个资源单位，其中包含了运行程序所需要的所有资源

    线程才是真正的执行单位，没有线程，进程中的资源无法被利用起来，
所以一个进程至少包含一个线程，称之为主线程，当我们启动一个程序时，
操作系统就会自己为这个程序创建一个主线程，线程也可以由程序后期开启，
自己开启的线程称之为子线程


那位什么需要线程：
    开进程：
        1 申请内存空间 ，耗资源
        2 拷贝代码 ，耗资源

    开线程：
        目的只有一个就是提高效率，将内存比如工厂，那么进程就相当于是工厂里面的车间，
        而你的线程就相当于是车间里面的流水线，要是生产量跟不上的话，你肯定是创建新的流水线，
        而不是创建一个新的工厂

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

四.开启线程的俩种方式

创建线程的俩种方式
跟创建进程的方式是一样的

一》

from threading import Thread
import time

def task(name):
    print('%s is running'%name)
    time.sleep(2)
    print('%s is over'%name)
# 注意：开启线程的时候不需要在__main__内
t = Thread(target=task,args=('zy',))
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(2)
        print('%s is over'%self.name)

t = MyThread('zy')
t.start()
print('主')

五.生产者消费者模型

生产者消费者是什么：

生产者消费者
生产者消费者模型是什么：
模型，就是解决摸个问题的套路，
产生数据的一方称之为生产者，
处理数据的一方称之为消费者，
列如：爬虫，生活中到处都是这种模型，
饭店 厨师即使生产者，你吃饭的人就是消费者

## 生产者和消费者出啥问题了?   解决什么问题
​    生产者和消费,处理速度不平衡,一方快一方慢,导致一方需要等待另一方
## 生产者消费者模型解决这个问题的思路:     怎么解决
​    原本,双方是耦合 在一起,消费必须等待生产者生成完毕在开始处理, 反过来
​    如果消费消费速度太慢,生产者必须等待其处理完毕才能开始生成下一个数据

### 解决的方案:
​    将双方分开来.一专门负责生成,一方专门负责处理
​    这样一来数据就不能直接交互了 双方需要一个共同的容器
​    生产者完成后放入容器,消费者从容器中取出数据
​    这样就解决了双发能力不平衡的问题,做的快的一方可以继续做,不需要等待另一方

列子：

生产者：生产/制造数据的
消费者：消费/处理数据的
例子：做包子的，买包子的
    1.做包子远比买包子的多
    2.做包子的远比买包子的少
    如何解决供需不平衡的问题

第一种解决方法：

第一个版本
from multiprocessing import Process,Queue,JoinableQueue
import random
import time


def zuo(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 chi(name,q):
    while True:
        data = q.get()
        if data == None:break# 判断取到的是否为空
        print('%s吃了%s'%(name,data))
        time.sleep(random.random())

if __name__ == '__main__':
    q = Queue()
    z = Process(target=zuo,args=('厨师zy','牛排',q))
    z1 = Process(target=zuo,args=('厨师xj','鸡排',q))
    c = Process(target=chi,args=('人',q))
    c1 = Process(target=chi,args=('动物',q))
    z.start()
    z1.start()
    c.start()
    c1.start()
    z.join()
    z1.join()# 没有这个的话，直接取空，消费者就结束了，确保生产者确确实实生产完了
    q.put(None) # 存进去一个None，只要消费者取值得时候取到空了，就带表生产的都被吃完了，然后结束程序
    q.put(None)

第一种方法的缺陷：没多一个人我就要多写一个None，要是人有成千上万怎么办

第二种方法：用JoinableQueue方法解决

JoinableQueue里面的方法：

JoinableQueue

可以被join的队列

join是等待任务结束

队列怎么叫结束?

调用task_done一次则表示有一个数据被处理完成了 当task_done次数等于put的次数就意味着任务处理完成了

这也是join的执行时机

该队列可以明确告知数据的使用方,所有数据都已经处理完成

在生产者消费者模型中,解决了消费者不知道何时算是任务结束的问题

具体过程:主进程先等待所有的生产者进程生成完毕,再等队列中的数据被全部处理,这就意味着,任务全部结束

from multiprocessing import Process,JoinableQueue
import random
import time


def zuo(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 chi(name,q):
    while True:
        data = q.get()
        print('%s吃了%s'%(name,data))
        time.sleep(random.random())
        q.task_done()# 告诉队列你已经从队列中取出了一个数据，并且处理完毕

if __name__ == '__main__':
    q = JoinableQueue()
    z = Process(target=zuo,args=('厨师zy','牛排',q))
    z1 = Process(target=zuo,args=('厨师xj','鸡排',q))
    c = Process(target=chi,args=('人',q))
    c1 = Process(target=chi,args=('动物',q))
    z.start()
    z1.start()
    c.daemon = True# 将消费者设为守护进程，主线程结束，子线程也就结束了
    c1.daemon = True
    c.start()
    c1.start()
    z.join()# 确保生产者确确实实生产完了
    z1.join()

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

六.线程的其他方法

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)
# 开线程不需要在__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.getpid())# 查看线程id

七.线程间是可以通讯的

from threading import Thread

money = 666

def task():
    global money
    money = 999

t = Thread(target=task)
t.start()
t.join()
print(money)

 线程之间是可以通信的，数据之间不是相互隔离的
结果是999

八.守护线程

一个线程可以设置为另一个线程的守护进程
特点：被守护线程结束后守护线程也随之结束

守护线程会等到所有非守护线程结束后结束！前提是除了主线程之外，还有其他的非守护线程
当然如果守护线程已经完成任务，就会立马结束

from threading import Thread
import time

def task():
    print("子1running......")
    time.sleep(5)
    print("子1over......")

def task2():
    print("子2running......")
    time.sleep(4)
    print("子2over......")

t = Thread(target=task)
t.daemon = True
t.start()

t2 = Thread(target=task2)
t2.start()
print("主over")

九.互斥锁

线程互斥锁
不管是进程还是线程，只要共享就意味着竞争，线程中也存在安全问题，
多线程可以并发执行，一旦并发了并且访问了同一个资源就会出现问题，
解决方案：还是要加互斥锁

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)

开100个线程，每一次都去减一，最终打印结果为0，如果不加锁的话打印结果为99，因为每个线程拿到的都是100,100减1等于99