线程编程(Thread)
- 什么是线程
- 线程被称为轻量级的进程
- 线程也可以使用计算机多核资源,是多任务编程方式
- 线程是系统分配内核的最小单元
- 线程可以理解为进程的分支任务
- 线程特征
- 一个进程中可以包含多个线程
- 线程也是一个运行行为,消耗计算机资源
- 一个进程中的所有线程共享这个进程的资源
- 多个线程之间的运行互不影响各自运行
- 线程的创建和销毁耗资源小于进程
- 各个进程也有自己的ID等特征
threading模块创建线程
创建线程对象
from threading import Thread
t = Thread()
功能：创建线程对象
参数：target 绑定线程函数
args 元组 给线程函数位置传参
kwargs 字典 给线程函数键值传参
启动线程
t.start()
回收线程
t.join([timeout])
线程基础使用示例:
1 import threading
2 from time import sleep
3 import os
4
5 a = 1
6
7 # 线程函数
8 def music():
9 global a
10 print("a = ",a)
11 a = 10000
12 for i in range(3):
13 sleep(2)
14 print(os.getpid(),"播放: 葫芦娃")
15
16 # 线程对象
17 t = threading.Thread(target = music)
18 t.start() # 启动线程
19
20 for i in range(4):
21 sleep(1)
22 print(os.getpid(),"播放: 黄河大合唱")
23
24 t.join() # 回收线程
25
26 print("===========================")
27
28 print("a:",a)
线程基础实例2:
1 from threading import Thread
2 from time import sleep
3
4 # 含有参数的线程函数
5 def fun(sec,name):
6 print("线程函数传参")
7 sleep(sec)
8 print("%s执行完毕"%name)
9
10 # 创建多个线程
11 jobs=[]
12 for i in range(3):
13 t = Thread(target=fun,args=(2,),
14 kwargs={'name':'T%d'%i})
15 jobs.append(t) # 存线程对象
16 t.start()
17
18 for i in jobs:
19 i.join()
线程对象属性
t.name 线程名称
t.is_alive() 查看线程是否在生命周期
t.daemon 设置主线程和分支线程的退出关系
t.setDaemon() 设置daemon属性值
t.isDaemon() 查看daemon属性值
daemon为True时主线程退出分支线程也退出。要在start前设置，通常不和join一起使用。
自定义线程类
- 创建步骤
- 继承Therad类
- 重写__init__方法添加自己的属性,使用super()加载父类属性
- 重写run()方法
- 使用方法
- 实例化对象
- 调用start自动执行run方法
- 调用join回收线程
自定义线程示例:
1 from threading import Thread
2 from time import sleep,ctime
3
4 class MyThread(Thread):
5 # __init__可以添加参数，进行编写
6 def __init__(self,target,args=(),kwargs={}):
7 super().__init__() # 此处不许传参
8 self.target = target
9 self.args = args
10 self.kwargs = kwargs
11
12 # 添加其他方法 run
13 def run(self):
14 self.target(*self.args,**self.kwargs)
15
16 ###########################################
17 def player(sec,song):
18 for i in range(3):
19 print("Playing %s:%s"%(song,ctime()))
20 sleep(sec)
21
22 t = MyThread(target=player,args=(3,),
23 kwargs={'song':'凉凉'})
24
25 t.start()
26 t.join()
同步互斥
线程间通信方法
通信方法
线程间使用全局变量进行通信
共享资源争夺
共享资源:多个进程或者线程都可以操作 的资源称为共享资源.对共享资源的操作代码段称为临界区
影响:对共享资源的无需操作可能会带来数据的混乱,或者操作错误.此时往往需要同步互斥机制协调操作顺序
同步互斥机制
同步:同步是一种协作关系,为完成操作,多进程或者多线程间形成一种协调,按照必要的步骤有序执行操作
互斥:互斥是一种制约关系,当一个进程或者线程占有资源时会进行加锁处理,此时其他进程就无法操作该资源,直到解锁后才能操作.
线程同步互斥方法
线程Event
from threading import Event e = Event() 创建线程event对象 e.wait([timeout]) 阻塞等待e被set e.set() 设置e，使wait结束阻塞 e.clear() 使e回到未被设置状态 e.is_set() 查看当前e是否被设置
互斥代码示例:
from threading import Thread,Event
s = None # 全局变量用于通信
e = Event() # 事件对象
def 杨子荣():
print("杨子荣前来拜山头")
global s
s = "天王盖地虎"
e.set() # 修改完s
t = Thread(target=杨子荣)
t.start()
print("说对口令就是自己人")
e.wait() #阻塞等待
if s == "天王盖地虎":
print("宝塔镇河妖")
print("确认过眼神，你是对的人")
else:
print("打死他!!")
t.join()
线程锁Lock
from threading import Lock lock = Lock() 创建锁对象 lock.acquire() 上锁 如果lock已经上锁再调用会阻塞 lock.release() 解锁 with lock: 上锁
线程锁代码示例:
1 from threading import Thread,Lock
2
3 a = b = 0
4 lock = Lock() # 锁对象
5
6 def value():
7 while True:
8 lock.acquire()
9 if a != b:
10 print('a = %d,b = %d'%(a,b))
11 lock.release() # 解锁操作
12
13 t = Thread(target=value)
14 t.start()
15
16 while True:
17 with lock: # with上锁
18 a += 1
19 b += 1
20 # 语句块结束解锁
21 t.join()
死锁及其处理
定义
死锁是指两个或者两个以上的线程在执行过程中,由于竞争资源或者由于彼此通信而总成的一种阻塞的现象,若无外力作用,他们都将无法推进下去.此时称系统处于死锁状态或系统产生了死锁
死锁产生条件
死锁代码示例:
1 from time import sleep
2 from threading import Thread,Lock
3
4 # 交易类
5 class Account:
6 def __init__(self,_id,balance,lock):
7 self.id = _id # 谁
8 self.balance = balance # 有多少钱
9 self.lock = lock # 锁
10
11 # 取钱
12 def withdraw(self,amount):
13 self.balance -= amount # 取多少
14
15 # 存钱
16 def deposit(self,amount):
17 self.balance += amount # 存多少
18
19 # 查看余额
20 def get_balance(self):
21 return self.balance
22
23 # 创建两个账户
24 Tom = Account('Tom',5000,Lock())
25 Alex = Account('Alex',8000,Lock())
26
27 # 转账行为
28 def transfer(from_,to,amount):
29 # 从 from_ --> to 转amount
30 if from_.lock.acquire(): # 锁住自己账户
31 from_.withdraw(amount) # 自己账户扣除
32 sleep(0.5)
33 if to.lock.acquire(): # 对方账户上锁
34 to.deposit(amount) # 对方账户增加
35 to.lock.release() # 对方解锁
36 from_.lock.release() # 自己解锁
37 print("%s给%s转了%d"%(from_.id,to.id,amount))
38
39 t1 = Thread(target=transfer,args=(Tom,Alex,2000))
40 t2 = Thread(target=transfer,args=(Alex,Tom,3500))
41
42 t1.start()
43 t2.start()
44
45 t1.join()
46 t2.join()
47
48 print(Tom.get_balance())
49 print(Alex.get_balance())
- 死锁发生的必要条件
- 互斥条件:指线程对所有分配到的资源进行排它性使用,即在一段时间内某资源只由一个进程占用.如果此时还有其他进程请求资源,则请求者只能等待.直至占有资源的进程用完毕释放
- 请求和保持条件:指线程已经保持至少一个资源,但又提出了新的资源请求,而该资源已被其它进程占有,此时请求线程阻塞,但又对自己已或得的其他资源保持不放
- 不剥夺条件:指线程已获得的资源,在未使用完之前,不能被剥夺,只能在使用完时由自己释放,通常CPU内存资源是可以被系统强行调配剥夺的.
- 环路等待条件:指在发生死锁时,必然存在一个线程------资源的环形链,即进程集合
{T0,T1,T2,....,Tn}中正在等待一个T1占用的资源;T1正在等待T2占用的资源,......,Tn正在等待已被T0占用的资源.
- 死锁的产生原因
- 简单来说造成死锁的原因可以概括成三句话:
- 当前线程拥有其他线程需要的资源
- 当前线程等待其他线程已拥有的资源
- 都不放弃自己拥有的资源
- 如何避免死锁
死锁是我们非常不愿意看到的一种现象,我们要尽可能避免死锁的情况发生.通过设置某些条件限制条件,去破坏产生死锁的四个必要条件中的一个或者几个,,来预防发生死锁.预防死锁是一种较易实现的方法.但是由于所施加的限制条件往往太严格,可能导致系统资源利用率.
python线程GIL
python线程的GIL问题(全局解释锁)
- 什么是GIL:由于python解释器设计中加入了解释器锁,导致python解释器同一时刻只能解释执行一个线程,大大降低了线程的执行效率
- 导致后果:因为遇到阻塞时线程会主动让出解释器,去解释其他线程.所以python多线程在执行多阻塞高延迟IO时可以提升程序效率,其他情况并不能对效率有所提升
GIL问题建议
- 尽量使用进程完成无阻塞的并发行为
- 不使用C作为解释器(Java C#)
进程线程的区别联系
区别联系
- 两者都是多任务编程方式,都能使用计算机多核资源
- 进程的创建删除消除的计算机资源比线程多
- 进程空间独立,数据互不干扰,有专门通信方法;线程使用全局变量通信
- 一个进程可以有多个分支线程,两者有包含关系
- 多个线程共享进程资源,在共享资源操作时往往需要同步互斥处理
- 进程线程在系统中都有自己的特有属性标志,如ID,代码段,命令集等
使用场景
- 任务场景:如果是相对独立的任务模块,可能使用多进程,如果是多个分支共同形成一个整体任务可能用多线程
- 项目结构:多种编程语言实现不同任务模块,可能是多进程,或者前后端分离应该各自为一个进程
- 难易程度:通信难度,数据处理的复杂度来判断用进程间通信还是同步互斥方法
要求
- 对进程线程怎么理解/说说进程线程的差异
- 进程间通信知道那些,有什么特点
- 什么是同步互斥,你什么情况下使用,怎么用
- 给一个情形,说说用进程还是线程,为什么
- 问一些概念,僵尸进程的处理,GIL问题,进程状态
来源：http://www.cnblogs.com/-xiaolong/p/11370842.html