Python多线程

一、概念

• 线程是CPU分配资源的基本单位，当程序开始运行，这个程序就变成了一个进程；
• 当有多线程编程时，一个进程包含多个线程（含主线程），使用线程可以实现程序大的开发任务。
• 多线程可以在同一个程序中运行，并且每个线程完成不同的任务
• 多线程实现后台服务程序可以同时处理多个任务，并不发生阻塞现象
• 多线程的程序设计的特点是能够提高程序执行效率和处理速度，Python程序可以同时并行运行多个相对独立的线程。

二、创建多线程
Python支持两种创建多线程方式：

• 通过threading.Thread()创建；
• 通过threading.Thread类创建；
  1、通过threading.Thread（）创建
  语法：
  thread.Thread(group=Nore,targt=None,args=(),kwargs={},*,daemon=None)

2.通过继承 threading.Thread 类的继承
示例：

import threading
class mythread(threading.Thread):
  def run(self):
    for i in range(1,10):
      print(i)
thread1 = mythread();
thread2 = mythread();
thread1.start()
thread2.start()

解释：自定义一个类继承threading.Thread,然后重写父类的run方法，线程启动时（执行start（））会自动执行该方法。

三、主线程
在Python中，主线程是第一个启动的线程。

• 父线程：如果启动线程A中启动了线程B，A就是B的父线程。
• 子线程：B就是A的子线程。
• 创建线程时有一个damon属性，用它来判断主线程，当daemon设置False时，线程不会随主线程退出而退出，主线程结束其他子线程会强制退出。
• 使用daemon注意：
• daemon属性必须在start（）之前设置，否则会引发，RuntimeError异常；
• 每个线程都由daemon属性，可以显示设置也可以不设置，不设置则取默认值None
• 如果子子线程不设置daemon属性，可以显示设置也可以不设置，不设置则取默认值None
• 如果子子线程不设置daemon属性，可以显示设置也可以不设置，不设置则取默认值None；
• 从主线程创建的所有线程不设置daemon属性，则默认都是daemon=False
  示例：

import time
import threading
def test():
 time.sleep(10)
 for i in range(10):
  print(i)
thread1 = threading.Thread(target=test,daemon=False)
thread1.start()
print('主线程完成了')

解释：当主线程运行完毕输出完之后，等待一下后输出0~9。如果将daemon=False该为daemon=True，则不会运行for i in range(10)语句。

四、阻塞线程
一个线程中调用另一个线程的join方法，调用者被阻塞，直到调用线程被终止。
语法形式：
join(timeout=None)
timeout 参数制定调用者等待多久，没有设置时，就一直等待被调用线程结束被调用线程结束。其中，一个线程可以被join多次调用。
示例：

import time
import threading
def test():
 time.sleep(5)
 for i in range(10):
  print(i)
thread1=threading.Thread(target=test)
thread1.start()
thread1.join()
print('主线程完成了')

解释：在thread1.start()后加thread1.join()添加join方法，输出时，主线程就会等待输出完0~9后再执行自己的print输出。

五、判断线程是否活动的
run（）用以表示线程活动的方法
start()启动线程
join()等待至线程终止
isAlive（）返回线程是否活动的
getAlive()返回线程名称
setName（）设置线程名称
示例：

from threading import Thread, Event
import time
def countdown(n, started_evt):
    print('正在运行')
    started_evt.set()
    while n > 0:
        print('时间', n)
        n -= 1
        time.sleep(2)
started_evt = Event()
print('开始倒计时')
t = Thread(target=countdown, args=(10, started_evt))
t.start()
started_evt.wait()
print('倒计时运行')

• Alive，顾名思义，它表示线程当前是否为可用状态，如果线程已经启动，并且当前没有任何异常的话，则返回true，否则为false

• Thread.isAlive() ：顾名思义，是表示当前线程时候为可用状态，即是否已经在启动，并且在运行的状态；

六、线程同步
1、同步概念

• 异步的情况下，同时又一个线程在修改共享数据，另一个线程在读取共享数据，当修改的共享数据的线程没有处理完毕，读取数据的线程肯定会得到错误的结果，如果采用多线程的同步控制机制，当处理共享数据的线程完成处理数据后，读取数据就读取数据。

• Python的锁就解决这一问题，锁住线程，只允许一个线程操作，其他线程排队等待，待当前线程操作完毕后，再按顺序一个一个来运行。

2. python的锁
   python的threading模块提供了RLock锁解决方法。在某一时间只能让一个线程操作的语句放到RLock的acquire方法和release方法之间，即acquire相当于给RLack上锁，而release相当于解锁。

示例：

import threading
class mythread(threading.Thread):
 def run(self):
  global x                   #声明一个全局变量
  lock.acquire()             #上锁
  x +=10
  print('%s:%d'%(self.name,x))
  lock.release()             #解锁
x = 0                        #设置全局变量初始值
lock = threading.RLock()     #创建可重入锁
list1 = []                   
for i in range(5):   
 list1.append(mythread())    #创建五个线程，放到同一列表中
for i in list1:
 i.start()                   #开启列表线程

3. python中的条件锁
   条件锁常用的方法：

~acquire([timeout]):调用关联锁的方法

~release()：解锁

~wait():使线程进入 Condition 的等待池等待通知并释放解锁。使用前线程必须已获得锁定，否则将抛出异常。

~notify():从等待池挑选一个线程并通知，收到通知的线程将自动调用 acquire() 尝试获得，其他线程仍然在等待池中等待通知，直到该线程收到通知 调用该方法，否则将会抛出异常。

~notify ALL():跟notify() 一样，但这个方法对应的是所有的线程。

示例：

题目：有几个生产车间生产，几个消费者购买，当生产达到一定数量时，停止生产。

import threading
import time
condtion = threading.Condition()
sheep = ['1件产品','1件产品','1件产品','1件产品','1件产品']
class Producer(threading.Thread):
    def __init__(self, name):
        super().__init__(name=name)
        pass
    def run(self):
        global condtion, sheep
        while True:
            time.sleep(0.1)
            condtion.acquire()
            if len(sheep) < 10:
                print(self.name + "生产了1件产品")
                sheep.append('1件产品')
                condtion.notifyAll()
                pass
            else:
                print("仓库满了，停止生产!")
                condtion.wait()
                pass
            condtion.release()
        pass
    pass
class Customer(threading.Thread):
    def __init__(self, name):
        super().__init__(name=name)
        pass
    def run(self):
        global condtion, sheep
        while True:
            time.sleep(0.1)
            condtion.acquire()
            if len(sheep) > 0:
                meat = sheep.pop()
                print(self.name + "购买了" + meat + "还剩多少" + str(len(sheep)) + "件")
                condtion.notifyAll()
                pass
            else:
                print("买光了，等待")
                condtion.wait()
                pass
            condtion.release()
        pass
    pass
if __name__ == "__main__":
    p1 = Producer("1号生产车间")
    p2 = Producer("2号生产车间")
    p3 = Producer("3号生产车间")
    p4 = Producer("4号生产车间")
    p5 = Producer("5号生产车间")
    p6 = Producer("6号生产车间")
    p1.start()
    p2.start()
    p4.start()
    p5.start()
    p6.start()
    c1 = Customer('小王')
    c2 = Customer('小李')
    c3 = Customer('小贾')
    c4 = Customer('小沈')
    c5 = Customer('小刘')
    c1.start()
    c2.start()
    c3.start()
    c4.start()
    c5.start()