进程线程编程

线程对象属性

代码示例: day8/thread_attr.py

t.name 线程名称
t.setName() 设置线程名称
t.getName() 获取线程名称

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

t.daemon 设置主线程和分支线程的退出关系
t.setDaemon() 设置daemon属性值
t.isDaemon() 查看daemon属性值

daemon为True时主线程退出分支线程也退出。要在start前设置,通常不和join一起使用。

"""
线程属性
"""
from threading import Thread
from time import sleep

def fun():
    sleep(15)
    print("线程对象属性")

t = Thread(target=fun,name='Tarena')

# 主线程退出分支线程也退出
# t.setDaemon(True)

t.start()

t.setName("Tedu") # 给线程起名字
print("Name:",t.getName())
print("is alive:",t.is_alive())

自定义线程类

代码示例: day8/myThread.py

1. 创建步骤
   【1】 继承Thread类
   【2】 重写 init 方法添加自己的属性,使用super()加载父类属性
   【3】 重写run()方法
2. 使用方法
   【1】 实例化对象
   【2】 调用start自动执行run方法
   【3】 调用join回收线程

"""
自定义线程类
"""
from threading import Thread
from time import sleep,ctime

class MyThread(Thread):
    def __init__(self,target=None,args=(),kwargs={}):
        super().__init__()  # 此行不许动
        self.target = target
        self.args = args
        self.kwargs = kwargs

    def run(self):
        self.target(*self.args,**self.kwargs)

# ===========================================
def player(sec,song):
    for i in range(3):
        print("Playing %s:%s"%(song,ctime()))
        sleep(sec)

t = MyThread(target=player,args=(2,),
             kwargs={'song':'凉凉'})
t.start()
t.join()

同步互斥

线程间通信方法

1. 通信方法
   线程间使用全局变量进行通信
2. 共享资源争夺
   共享资源:多个进程或者线程都可以操作的资源称为共享资源。对共享资源的操作代码段称为临界区。
   影响 :
   对共享资源的无序操作可能会带来数据的混乱,或者操作错误。此时往往需要同步互斥机制协调操作顺序。
3. 同步互斥机制
   同步 : 同步是一种协作关系,为完成操作,多进程或者线程间形成一种协调,按照必要的步骤有序执行操作。
   
   互斥 : 互斥是一种制约关系,当一个进程或者线程占有资源时会进行加锁处理,此时其他进程线程就无法操作该资源,直到解锁后才能操作。
   

线程同步互斥方法

线程Event

代码示例: day8/thread_event.py
from threading import Event

e = Event()
创建线程event对象

e.wait([timeout])
阻塞等待e被set

e.set()
设置e,使wait结束阻塞

e.clear() 使e回到未被设置状态

e.is_set()
查看当前e是否被设置

"""
thread_event 互斥方法演示
"""
from threading import Thread,Event

s = None # 用于通信 ，共享资源
e = Event() # 事件对象

def 杨子荣():
    print("杨子荣前来拜山头")
    global s
    s = "天王盖地虎"
    e.set() # 解除阻塞

t = Thread(target=杨子荣)
t.start()
print("说对口令就是自己人")
e.wait() # 阻塞
if s == '天王盖地虎':
    print("宝塔镇河妖")
    print("确认过眼神，你是对的人")
else:
    print("打死他。。。。。")
t.join()

线程锁 Lock

代码示例: day8/thread_lock.py
from threading import Lock
lock = Lock() 创建锁对象
lock.acquire() 上锁 如果lock已经上锁再调用会阻塞
lock.release() 解锁
with lock:上锁

…
…
with代码块结束自动解锁

"""
thread lock 互斥方法示例
"""
from threading import Thread,Lock

a = b = 0  # 共享资源
lock = Lock() # 定义锁

def value():
    while True:
        lock.acquire() # 上锁
        if a != b:
            print("a = %d,b = %d"%(a,b))
        lock.release() # 解锁

t = Thread(target=value)
t.start()
while True:
    with lock:  # 上锁
        a += 1
        b += 1
               # 解锁
t.join()

死锁及其处理

1. 定义
   死锁是指两个或两个以上的线程在执行过程中,由于竞争资源或者由于彼此通信而造成的一种阻
   塞的现象,若无外力作用,它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁。
   
2. 死锁产生条件

互斥条件:指线程对所分配到的资源进行排它性使用,即在一段时间内某资源只由一个进程占用。如果此时还有其它进程请求资源,则请求者只能等待,直至占有资源的进程用毕释放。
请求和保持条件:指线程已经保持至少一个资源,但又提出了新的资源请求,而该资源已被其它进程占有,此时请求线程阻塞,但又对自己已获得的其它资源保持不放。
不剥夺条件:指线程已获得的资源,在未使用完之前,不能被剥夺,只能在使用完时由自己释放,通常CPU内存资源是可以被系统强行调配剥夺的。
环路等待条件:指在发生死锁时,必然存在一个线程——资源的环形链,即进程集合{T0,T1,T2,···,Tn}中的T0正在等待一个T1占用的资源;T1正在等待T2占用的资源,…,Tn正在等待已被T0占用的资源。
死锁的产生原因
简单来说造成死锁的原因可以概括成三句话:
当前线程拥有其他线程需要的资源
当前线程等待其他线程已拥有的资源
都不放弃自己拥有的资源
3. 如何避免死锁
死锁是我们非常不愿意看到的一种现象,我们要尽可能避免死锁的情况发生。通过设置某些限制条件,去破坏产生死锁的四个必要条件中的一个或者几个,来预防发生死锁。预防死锁是一种较易实现的方法。但是由于所施加的限制条件往往太严格,可能会导致系统资源利用率。

"""
模拟死锁的产生过程
"""
from time import sleep
from threading import Thread,Lock

# 账户类
class Account:
    def __init__(self,_id,balance,lock):
        self.id = _id # 账户名
        self.balance = balance # 存款
        self.lock = lock # 锁

    # 取钱
    def withdraw(self,amount):
        self.balance -= amount

    # 存钱
    def deposit(self,amount):
        self.balance += amount

    # 查看余额
    def get_balance(self):
        return self.balance

# 创建两个账户
Tom = Account('Tom',5000,Lock())
Alex = Account('Alex',8000,Lock())

def transfer(from_,to,amount):
    """
    :param from_: 从该账户转钱
    :param to:  给这个账户转入
    :param amount: 转账金额
    :return: None
    """
    from_.lock.acquire()  # from_上锁
    from_.withdraw(amount) # from_减少
    sleep(0.1)
    from_.lock.release()  # from_解锁
    to.lock.acquire() # to上锁
    to.deposit(amount) # to钱增加
    to.lock.release() # to解锁
    # from_.lock.release() # from_解锁


t1=Thread(target=transfer,args=(Tom,Alex,1500))
t2=Thread(target=transfer,args=(Alex,Tom,3000))
t1.start()
t2.start()
t1.join()
t2.join()

print("Tom:",Tom.get_balance())
print("Alex:",Alex.get_balance())

python线程GIL

1. python线程的GIL问题 (全局解释器锁)
   什么是GIL :由于python解释器设计中加入了解释器锁,导致python解释器同一时刻只能解释执行一个线程,大大降低了线程的执行效率。
   导致后果: 因为遇到阻塞时线程会主动让出解释器,去解释其他线程。所以python多线程在执行多阻塞高延迟IO时可以提升程序效率,其他情况并不能对效率有所提升。
   GIL问题建议
   尽量使用进程完成无阻塞的并发行为
   不使用c作为解释器 (Java C#)

2. 结论 : 在无阻塞状态下,多线程程序和单线程程序执行效率几乎差不多,甚至还不如单线程效率。但是多进程运行相同内容却可以有明显的效率提升。

进程线程的区别联系

区别联系

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

使用场景

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

要求

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