线程

目录

• 线程
  • IPC机制
  • 生产者消费者模型
  • 线程理论
  • 开启线程的两种方式
  • 线程特性介绍
  • 守护线程
  • 线程互斥锁

线程

IPC机制

两个进程，产生数据先产生在内存中，数据交互就是一个进程把它在内存里的数据交给另一个进程，进程之间的内存空间是隔离的，所以一个进程没办法直接将数据交给另一个进程，内存空间是隔离的，可以找到一个共享的空间
主进程要想获取子进程的数据，将子进程数据输入管道内，也就是共享空间（硬盘（在输入输出数据的时候需要通过硬盘的io,速度比较慢），还有管道（在内存空间，速度快）），有时候需要修改不同的共享数据，为了确保数据的安全性，所以要加多把锁，能实现这两种需求的只有队列（内存空间中，并且可以解决锁的问题）
# 队列:先进先出
# 堆栈:先进后出
利用队列实现进程间通信
队列=管道+锁
#（一般队列中放小数据，文件放入需要转为二进制，视频就不建议放入队列中了）
from multiprocessing import Queue
# q=Queue() 不设置大小的话，可以无限放，其实也是有限制的，因为再怎么大也大不过内存空间
q=Queue(3) # 这是造出内存空间，括号内放入的是队列的大小
q.put(['first',]) # put中可放任意python类型，容器类型如果只有一个值，一定要加括号
q.put({'x':2})
q.put(3)
# q.put(4) 第四个，这里只是设置了3个队列大小，队列已满，会造成阻塞

print(q.get())# 会一直等，等到天荒地老，直到取到值为止，
print(q.get())
print(q.get())
# print(q.get()) 造成阻塞，等着需要放入的数据再取
结果：（先进先出）
['first',]
{'x':2}
3

了解：
# q=Queue(3)
# q.put(['first',],block=True,timeout=3) block=True表示队列满的时候就锁你，timeout=3表示就是阻你三秒
# q.put({'x':2},block=True,timeout=3)
# q.put(3,block=True,timeout=3)
# q.put(4,block=True,timeout=3) timeout=3阻你三秒，如果队列满了，block=True,就会阻塞，然后抛异常说队列满了，本来是可以干其他事，可现在不能了，因为阻塞在了原地，等到别人取走一个，我立马放入，放完才能生产数据，接着往里面放   block 和timeout是联合使用的，tomeout一般默认是-1表示就是我会一直等着，直到有数据放入
q.put_nowait(1) #q.put(1,block=False) 不用等
q.put_nowait(2)
q.put_nowait(3)
q.put_nowait(4) # 第四个，队列已满，所以会抛异常

print(q.get(block=True,timeout=3)) #如果取到值就不用等，如果没有就是等三秒，还没的话就会报错
print(q.get(block=True,timeout=3))
print(q.get(block=True,timeout=3))
print(q.get(block=True))# 如果不写timeout就会一直等死

print(q.get_nowait()) #q.get(block=false)
print(q.get_nowait()) #q.get(block=false)
print(q.get_nowait()) #q.get(block=false)
print(q.get_nowait()) #q.get(block=false) 连等都不等就报错了

生产者消费者模型

(三种运行方式：并发，并行，串行)
（生产者生产时，不能消费，消费时，不能生产，所以只能是并发，并发只有进程）
（两个进程：生产进程，消费进程）

'''
1. 什么是生产者消费者模型
    生产者:代指生产数据的任务
    消费者:代指处理数据的任务
    该模型的工作方式:
        生产者生产数据传递消费者处理

        实现方式:
            生产者---->队列<------消费者

2. 为何要用
    当程序中出现明细的两类任务,一类负责生产数据,一类负责处理数据
    就可以引入生产者消费者模型来实现生产者与消费者的解耦合,平衡生产能力与消费能力,从提升效率

3. 如何用
'''

# 在造数据的过程当中，消费者不能去消费，在消费的过程当中，是不能去造数据
#而以下数据就是我生产一个包子，要等它吃了才能再生产，这会造成效率问题，
# 在你吃包子的过程中，我应该是有能力去造包子的，而因为你，我还要等，白白浪费了生产的资源，
# 然后消费者同时吃完了还要等生产包子
# 以下就是耦合
def producers():
    for i in range(10):
        # 造数据
        consumers(i)


def consumers(res):
    pass

# 提高效率：消费者和生产者之间可以有一个沟通的介质（一个盆，生产包子的时候就往里丢），厨师在后台做，
# 消费者可以不停的吃（在盆里挑包子）
# 结耦合


import time, random

from multiprocessing import Queue, Process


def producer(name, food, q):
    for i in range(10):
        res = '%s%s' % (food, i)
        time.sleep(random.randint(1, 3)) #模拟生产数据的时间
        q.put(res)
        print('厨师%s生产了%s' % (name, res))


def consumer(name, q):
    while True:
        res = q.get() # 会一直等，等到取到值为止才会运行下面的代码，
        # 所以不会出现包子产生了一个，我吃了两个
        time.sleep(random.randint(1, 3))
        print('吃货%s吃了%s' % (name, res))


if __name__ == '__main__':
    q = Queue()
    #生产者们
    p1 = Process(target=producer, args=('egon', '包子', q)) #子进程是一个独立的内存空间，
    # 现在的子进程功能只是主进程的一个相同功能
    # 消费者
    c1 = Process(target=consumer, args=('刘清政', q))
    p1.start() # 是生产者先告诉操作系统的，所以操作系统会先造出生产者造出包子，才到消费
    c1.start()
    print('主')  # 主进程包括这两个功能


#以上的代码是生产者生产完了（一个函数运行完就结束了），
# 消费者因为while True而没有结束函数循环，所以会执行res = q.get(),
# 此时生产者已经没有数据了，就会造成阻塞，一直在等
#以下优化

import time , random


from multiprocessing import Queue, Process


def produce(food, q, name):
    for i in range(10):
        res = '%s%s' % (food, i)
        time.sleep(random.randint(1, 3))
        q.put(res)
        print('厨师%s生产了%s' % (name, res))
    q.put(None)


def cost(q, name):
    while True:
        res = q.get()
        if res is None: break
        time.sleep(random.randint(1, 3))
        print('吃货%s吃了%s' % (name, res))


if __name__ == '__main__':
    q = Queue()
    p1 = Process(target=produce, args=('包子', q, 'egon'))
    c1 = Process(target=cost, args=(q, '刘清政'))
    p1.start()
    c1.start()
    print('主')



# 多用户
import time , random

from multiprocessing import Queue, Process


def made(name, q, food):
    for i in range(5):
        res = '%s%s' % (food, i)
        time.sleep(random.randint(1, 3))
        q.put(res)
        print('厨师%s生产了%s' % (name, res))
    q.put(None)


def spend(name, q):
    while True:
        res = q.get()
        if res is None: break
        time.sleep(random.randint(1, 3))
        print('吃货%s吃了%s' % (name, res))


if __name__ == '__main__':
    q = Queue()
    p1 = Process(target=made, args=('yaya', q, '包子'))
    p2 = Process(target=made, args=('dd', q, '露水'))
    p3 = Process(target=made, args=('ww', q, '串串'))
    c1 = Process(target=spend, args=('吴三江', q))
    c2 = Process(target=spend, args=('egon', q))
    p1.start()
    p2.start()
    p3.start()
    c1.start()
    c2.start()
    print('主')
# 以上代码多用户下，三个用户都是在一个队列中取值，不能保证同时都结束for循环 ，所以有些消费者不能消费完就就结束掉了
import time , random

from multiprocessing import Queue, Process


def made(name, q, food):
    for i in range(5):
        res = '%s%s' % (food, i)
        time.sleep(random.randint(1, 3))
        q.put(res)
        print('厨师%s生产了%s' % (name, res))



def spend(name, q):
    while True:
        res = q.get()
        time.sleep(random.randint(1, 3))
        print('吃货%s吃了%s' % (name, res))


if __name__ == '__main__':
    q = Queue()
    p1 = Process(target=made, args=('yaya', q, '包子'))
    p2 = Process(target=made, args=('dd', q, '露水'))
    p3 = Process(target=made, args=('ww', q, '串串'))
    c1 = Process(target=spend, args=('吴三江', q))
    c2 = Process(target=spend, args=('egon', q))
    p1.start()
    p2.start()
    p3.start()
    c1.start()
    c2.start()
    p1.join()
    p2.join()
    p3.join()
    q.put(None)
    q.put(None)
    print('主')

# 以上是等三个生产者子进程结束运行之后，由于两个消费者因为while循环而没有接收，
# 需要传值，不然就一直在等，而主进程和所以的子进程都是共用一个队列的，
# 所以在等生产者子进程结束后就给两个消费者传值，停止运行


import time, random

from multiprocessing import JoinableQueue, Process

def product(q, name, food):
    for i in range(5):
        res = '%s%s' % (food, i)
        time.sleep(random.randint(1, 3))
        q.put(res)
        print('厨师%s生产了%s' % (name, res))

def client(q,name):
    while True:
        res = q.get()
        time.sleep(random.randint(1, 3))
        print()
        print('厨师%s生产了%s' % (name, res))
        q.task_done() # 给q.join发送消息。
        # 每循环一次，
        # 走到这行代码就代表了队列中的一个值被取走了，
        # 然后这一代码就是告诉q.join,q.join就会计算本来队列中所存的值再相减
        # q.join每收到一次信息就减一，直到清零后就会自动跳出子进程的运行，
        # 所以下面的q.join是等三个生产者都运行完后才计算队列中的值个数，
        # 主要是计算消费者取值的次数,待消费者取值结束后也就是运行结束后就跳出

if __name__ == '__main__':
    q = JoinableQueue()
    p1 = Process(target=made, args=('yaya', q, '包子'))
    p2 = Process(target=made, args=('dd', q, '露水'))
    p3 = Process(target=made, args=('ww', q, '串串'))
    c1 = Process(target=spend, args=('吴三江', q))
    c2 = Process(target=spend, args=('egon', q))
    p1.start()
    p2.start()
    p3.start()
    c1.start()
    c2.start()
    p1.join()
    p2.join()
    p3.join()
    q.join() # 主进程等q结束,即q内数据被取干净了
    print('主') # 运行这行代码就表示q.join（）运行完了，
    # 生产者正常死亡，消费者也消费完了


# 终极版本
import time,random
from multiprocessing import Process,JoinableQueue

def producer(name,food,q):
    for i in range(3):
        res='%s%s' %(food,i)
        time.sleep(random.randint(1,3)) #模拟生产数据的时间
        q.put(res)
        print('厨师[%s]生产了<%s>' %(name,res))

def consumer(name,q):
    while True:
        res=q.get()
        time.sleep(random.randint(1,3)) #模拟处理数据的时间
        print('吃货[%s]吃了<%s>' %(name,res))
        q.task_done()

if __name__ == '__main__':
    q=JoinableQueue()
    # 生产者们
    p1=Process(target=producer,args=('小Egon','泔水',q))
    p2=Process(target=producer,args=('中Egon','屎包子',q))
    p3=Process(target=producer,args=('大Egon','腰子汤',q))
    # 消费者们
    c1=Process(target=consumer,args=('刘清正',q))
    c2=Process(target=consumer,args=('吴三江',q))
    c1.daemon=True  #  守护进程，代表消费者消费完后也应该跟着主进程死掉
    c2.daemon=True

    p1.start()
    p2.start()
    p3.start()
    c1.start()
    c2.start()

    p1.join()
    p2.join()
    p3.join()
    q.join() # 主进程等q结束,即q内数据被取干净了
    print('主')

线程理论

自己的理解（操作系统就是一个工厂，多个车间，每个车间就是进程，进程就是资源单位，主要就是开辟内存空间，而车间内都自带一条流水线，流水线就是线程，线程就是执行单位，就是比如修车功能，拆轮胎功能等，一个线程就是一个功能。一个进程中可以有多个线程，提高程序运行的执行效率，一个进程中的多个线程可以共用资源。）

1 什么是线程
    进程其实一个资源单位,而进程内的线程才是cpu上的执行单位
    线程其实指的就是代码的执行过程

2 为何要用线程
    线程vs进程
        2.1. 同一进程下的多个线程共享该进程内的资源
        2.2. 创建线程的开销要远远小于进程

开启线程的两种方式

#开启线程的方式一：
from threading import Thread
import time

def task(name):
    print('%s is running' %name)
    time.sleep(2)
    print('%s is done' %name)

if __name__ == '__main__':
    t=Thread(target=task,args=('线程1',))  # 创建进程的multiprocessing类其实是复制threading的接口，所以创建进程和创建线程的方法基本一样
    t.start()
    print('主') #主线程是不存在的，线程之间部分主次，这是约定熟成的主线程


#开启线程的方式二：
from threading import Thread
import time

class Mythread(Thread):
    def run(self):
        print('%s is running' %self.name)
        time.sleep(2)
        print('%s is done' %self.name)

if __name__ == '__main__':
    t=Mythread()
    t.start()
    print('主')

线程特性介绍

from threading import Thread
import time

n=100
def task():
    global n
    n=0

if __name__ == '__main__':
    t=Thread(target=task)
    t.start()
    t.join()
    print('主',n) #0  证明主线程和多个子线程共享进程内的所有资源


    
from threading import Thread
import time,os

def task():
    print('%s is running' %os.getpid())

if __name__ == '__main__':
    t=Thread(target=task)
    t.start()
    print('主',os.getpid()) # 获取这个线程所属进程的id

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

def task():
    print('%s is running' % current_thread().name)
    time.sleep(2)

if __name__ == '__main__':
    t=Thread(target=task,)创建一个线程的默认名字thread-1代表是第一条线程，也可以自己取名name='momo'
    t.start()
    # t.join()
    print('主', active_count()) # 查看进程存活的线程个数 ，如果没有创建线程，也会默认为1，因为一个进程中默认自带一个线程
    print('主',current_thread().name) # 查看当前线程的父线程的名字

守护线程

# from threading import Thread
# import time
#
# def task(name):
#     print('%s is running' %name)
#     time.sleep(2)
#     print('%s is done' %name)
#
# if __name__ == '__main__':
#     t=Thread(target=task,args=('线程1',))
#     t.daemon=True
#     t.start()
#     print('主')


from threading import Thread
from multiprocessing import Process
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=Process(target=foo)
    # t2=Process(target=bar)
    t1.daemon=True
    t1.start()
    t2.start()
    print("main-------")

    '''
    123
    main-------
    456
    end456
    '''

    '''
    main-------
    123
    456
    end456
    '''

    '''
    main-------
    456
    end456
    '''

线程互斥锁

from threading import Thread,Lock
import time

mutex=Lock()
n=100
def task():
    global n
    mutex.acquire()
    temp=n
    time.sleep(0.1)
    n=temp-1
    mutex.release()

if __name__ == '__main__':
    t_l=[]
    for i in range(100):
        t=Thread(target=task)
        t_l.append(t)
        t.start()

    for t in t_l:
        t.join()
    print(n)