一 、线程的概念
线程是CPU分配资源的基本单位 。当一程序开始运行 ，这个程序就变成了一个进程 ，而一个进程相当于一个或者多个线程 。当没有多线程编程时 ，一个进程相当于一个主线程；当有多线程编程时 ，一个进程包含多个线程（含主线程） 。使用线程可以实现程序大的开发 。
多个线程可以在同一个程序中运行 ，并且每一个线程完成不同的任务 。
多线程实现后台服务程序可以同时处理多个任务 ，并不发生阻塞现象 。
多线程的程序设计的特点就是能够提高程序执行效率和处理速度 。python程序可以同时并行运行多个相对独立的线程 。
二 、创建多线程
python支持两种创建多线程的方式：
~通过 threading.Thread () 创建 。
~通过继承 threading.Thread 类的继承 。
1.通过 threading.Thread () 创建
语法形式：
参数解释：
~group：必须为None ，于ThreadGroup类相关 ，一般不使用 。
~target：线程调用的对象 ，就是目标函数 。
~name：为线程起这个名字 。默认是Tread-x ，x是序号 ，由1开始 ，第一个创建的线程名字就是Tread-1 。
~args：为目标函数传递关键字参数 ，字典 。
~daemon：用来设置线程是否随主线程退出而退出 。
示例：
import threading
def test (x,y):
for i in range(x,y):
print(i)
thread1 = threading.Thread(name=t1,target= test,args=(1,10))
thread2 = threading.Thread(name=t2,target= test,args=(11,20))
thread1.start() #启动线程1
thread2.start() #启动线程2
1
2
3
4
5
6
7
8
9
11
12
13
14
15
16
17
18
19
解释：两个程序会并发运行 ，所以结果不一定每次都是顺序的1~10 ，这是根据CPU给两个线程风马分配的时间片段来决定 。可以看到每次结果都不同 。
2.通过继承 threading.Thread 类的继承
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()
输出：
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9
解释：自定义一个类继承threading.Thread,然后重写父类的run方法 ，线程启动时（执行start（））会自动执行该方法 。
三 、主线程
在python中 ，主线程是第一个启动的线程 。
~父线程:如果启动线程A中启动了一个线程B ，A就是B的父线程 。
~子线程：B就是A的子线程 。
创建线程时有一个damon属性 ，用它来判断主线程 。当daemon设置False时 ，线程不会随主线程退出而退出 ，主线程会一直等着子线程执行完; 。当daemon设置True时 ，线程会随主线程退出而退出 ，主线程结束其他的子线程会强制退出 。
使用daemon注意：
~daemon属性必须在start( )之前设置 ，否则会引发RuntimeError异常
~每个线程都由daemon属性 ，可以显示设置也可以不设置 ，不设置则取默认值None
~如果子子线程不设置daemon属性 ，就取当前线程的daemon来设置它 。子子线程继承子线程的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(主线程完成了)
输出：
主线程完成了
1
2
3
4
5
6
7
8
9
解释：当主线程运行完毕输出完之后 ，等待一下后输出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(主线程完成了)
输出：
0
1
2
3
4
5
6
7
8
9
主线程完成了
解释：在thread1.start()后加thread1.join()添加join方法 ，输出时 ，主线程就会等待输出完0~9后再执行自己的print输出 。
五 、判断线程是否活动的
~run（）：用以表示线程活动的方法
~start（）：启动线程
~join（）：等待至线程终止
~isAlive（）：返回线程是否活动的
~getName（）：返回线程名称
~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(倒计时运行)
输出：
开始倒计时
正在运行
时间 10
倒计时运行
时间 9
时间 8
时间 7
时间 6
时间 5
时间 4
时间 3
时间 2
时间 1
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() #开启列表线程
输出：
Thread-1:10
Thread-2:20
Thread-3:30
Thread-4:40
Thread-5:50
解释：
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()
声明：本站所有文章 ，如无特殊说明或标注 ，均为本站原创发布 。任何个人或组织 ，在未征得本站同意时 ，禁止复制 、盗用 、采集 、发布本站内容到任何网站 、书籍等各类媒体平台 。如若本站内容侵犯了原著者的合法权益 ，可联系我们进行处理 。
