python多任务编程---线程

线程编程(Thread)

• 什么是线程

1. 线程被称为轻量级的进程
2. 线程也可使用计算机多核资源,是多任务编程方式
3. 线程是系统分配内核的最小单元
4. 线程能够理解为进程的分支任务

• 线程特征

1. 一个进程中能够包含多个线程
2. 线程也是一个运行行为,消耗计算机资源
3. 一个进程中的全部线程共享这个进程的资源
4. 多个线程之间的运行互不影响各自运行
5. 线程的建立和销毁耗资源小于进程
6. 各个进程也有本身的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)

View Code

 

线程基础实例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()

View Code

 

线程对象属性

t.name 线程名称

t.is_alive() 查看线程是否在生命周期

t.daemon 设置主线程和分支线程的退出关系

t.setDaemon() 设置daemon属性值

t.isDaemon() 查看daemon属性值

　　daemon为True时主线程退出分支线程也退出。要在start前设置，一般不和join一块儿使用。

自定义线程类

• 建立步骤

1. 继承Therad类
2. 重写__init__方法添加本身的属性,使用super()加载父类属性
3. 重写run()方法

• 使用方法

1. 实例化对象
2. 调用start自动执行run方法
3. 调用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()

View Code

 

同步互斥

线程间通讯方法

通讯方法

线程间使用全局变量进行通讯

共享资源争夺

共享资源:多个进程或者线程均可以操做 的资源称为共享资源.对共享资源的操做代码段称为临界区

影响:对共享资源的无需操做可能会带来数据的混乱,或者操做错误.此时每每须要同步互斥机制协调操做顺序

同步互斥机制

同步:同步是一种协做关系,为完成操做,多进程或者多线程间造成一种协调,按照必要的步骤有序执行操做

互斥:互斥是一种制约关系,当一个进程或者线程占有资源时会进行加锁处理,此时其余进程就没法操做该资源,直到解锁后才能操做.

 线程同步互斥方法

线程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()

View Code

 

 

线程锁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()

View Code

 

 死锁及其处理

定义

死锁是指两个或者两个以上的线程在执行过程当中,因为竞争资源或者因为彼此通讯而总成的一种阻塞的现象,若无外力做用,他们都将没法推动下去.此时称系统处于死锁状态或系统产生了死锁

死锁产生条件

死锁代码示例:

 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())

View Code  

•  死锁发生的必要条件

1. 互斥条件:指线程对全部分配到的资源进行排它性使用,即在一段时间内某资源只由一个进程占用.若是此时还有其余进程请求资源,则请求者只能等待.直至占有资源的进程用完毕释放
2. 请求和保持条件:指线程已经保持至少一个资源,但又提出了新的资源请求,而该资源已被其它进程占有,此时请求线程阻塞,但又对本身已或得的其余资源保持不放
3. 不剥夺条件:指线程已得到的资源,在未使用完以前,不能被剥夺,只能在使用完时由本身释放,一般CPU内存资源是能够被系统强行调配剥夺的.
4. 环路等待条件:指在发生死锁时,必然存在一个线程------资源的环形链,即进程集合

　　　　{T0,T1,T2,....,Tn}中正在等待一个T1占用的资源;T1正在等待T2占用的资源,......,Tn正在等待已被T0占用的资源.

• 死锁的产生缘由
• 简单来讲形成死锁的缘由能够归纳成三句话:

1. 当前线程拥有其余线程须要的资源
2. 当前线程等待其余线程已拥有的资源
3. 都不放弃本身拥有的资源

• 如何避免死锁

　　死锁是咱们很是不肯意看到的一种现象,咱们要尽量避免死锁的状况发生.经过设置某些条件限制条件,去破坏产生死锁的四个必要条件中的一个或者几个,,来预防发生死锁.预防死锁是一种较易实现的方法.可是因为所施加的限制条件每每太严格,可能致使系统资源利用率.

python线程GIL

 python线程的GIL问题(全局解释锁)

• 什么是GIL:因为python解释器设计中加入了解释器锁,致使python解释器同一时刻只能解释执行一个线程,大大下降了线程的执行效率
• 致使后果:由于遇到阻塞时线程会主动让出解释器,去解释其余线程.因此python多线程在执行多阻塞高延迟IO时能够提高程序效率,其余状况并不能对效率有所提高  

GIL问题建议

1. 尽可能使用进程完成无阻塞的并发行为
2. 不使用C做为解释器(Java　　C#)

进程线程的区别联系

区别联系

1. 二者都是多任务编程方式,都能使用计算机多核资源
2. 进程的建立删除消除的计算机资源比线程多
3. 进程空间独立,数据互不干扰,有专门通讯方法;线程使用全局变量通讯
4. 一个进程能够有多个分支线程,二者有包含关系
5. 多个线程共享进程资源,在共享资源操做时每每须要同步互斥处理
6. 进程线程在系统中都有本身的特有属性标志,如ID,代码段,命令集等

使用场景

1. 任务场景:若是是相对独立的任务模块,可能使用多进程,若是是多个分支共同造成一个总体任务可能用多线程
2. 项目结构:多种编程语言实现不一样任务模块,多是多进程,或者先后端分离应该各自为一个进程
3. 难易程度:通讯难度,数据处理的复杂度来判断用进程间通讯仍是同步互斥方法

要求

1. 对进程线程怎么理解/说说进程线程的差别
2. 进程间通讯知道那些,有什么特色
3. 什么是同步互斥,你什么状况下使用,怎么用
4. 给一个情形,说说用进程仍是线程,为何
5. 问一些概念,僵尸进程的处理,GIL问题,进程状态