并发编程（三）—— 线程编程、同步互斥（线程锁）、GIL

线程编程（Thread）

线程基本概念

1. 什么是线程
   【1】线程被称为轻量级的进程
   【2】线程也可以使用计算机多核资源，是多任务编程方式
   【3】线程是系统分配内核的最小单元（有可能多个线程占用多个内核）
   【4】线程可以理解为进程的分支任务
   
2. 线程特征
   【1】一个进程中可以包含多个线程
   【2】线程也是一个运行行为，消耗计算机资源
   【3】一个进程中的所有线程共享这个进程的资源
   【4】多个线程之间的运行互不影响各自运行
   【5】线程的创建和销毁消耗资源远小于进程
   【6】各个线程也有自己的ID等特征

threading模块创建线程

【1】 创建线程对象

from threading import Thread 

t = Thread()
功能：创建线程对象
参数：target 绑定线程函数
　　　args 元组 给线程函数位置传参
　　　kwargs 字典 给线程函数键值传参

【2】 启动线程

t.start()

【3】 回收线程

t.join([timeout])

单线程（无参数）：

from threading import Thread
from time import sleep
import os

a=1
def music():
	global a
	print("a=",a)# 1
    a = 10000
    for i in range(5):
        sleep(2)
        print(os.getpid(),"播放心如止水")

# 创建线程对象
t = Thread(target=music)
t.start()

# 主线程任务
for i in range(3):
    sleep(3)
    print(os.getpid(),"播放跳舞吧")

t.join()  # 回收进程

# 同一进程，分支线程将变量值更改，主线程变量值也随之更改(区分多进程，两个进程间互不影响)
print("Main thread a:",a)#10000

多线程（有参数）：

from threading import Thread
from time import sleep

# 含有参数的线程函数
def fun(sec, name):
    print("线程函数传参")
    sleep(sec)
    print("%s 线程执行完毕" % name)

# 创建多个线程
jobs = []
for i in range(5):
    t = Thread(target=fun, args=(2,),
               kwargs={'name': 'T%d' % i})
    jobs.append(t)
    t.start()

for i in jobs:
    i.join()

线程对象属性

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(3)
    print("线程属性测试")

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

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

t.start()

t.setName("Tedu")
print("Name:", t.getName())  # 线程名称（默认Thread-1）
print("Alive:", t.is_alive())  # 线程生命周期
print("is Daemon", t.isDaemon())

自定义线程类

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

重点代码：

from threading import Thread

class ThreadClass(Thread):
    def __init__(self, attr):
        self.attr = attr
        super().__init__()  # 调用父类的init方法

    def f1(self):
        print("步骤1", self.attr)

    def f2(self):
        print("步骤2")

    # 父类方法重写
    def run(self):
        self.f1()
        self.f2()

t = ThreadClass('XXXXX')
t.start()  # 自动运行run方法
t.join()

小练习：

from threading import Thread
from time import sleep, ctime

class MyThread(Thread):
	# pass
    # 解答如下：
    def __init__(self, target=None, args=(),
                 kwargs={}, name="AAA"):
        super().__init__()
        self.target = target
        self.args = args
        self.kwargs = kwargs
        self.name = name

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

# **********************************
# 通过完成上面的MyThread类让整个程序可以正常执行
# 当调用start时player作为一个线程功能函数运行
# 注意：函数名称和参数并不确定，player只是测试函数
# **********************************

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

t = MyThread(target=player, args=(3,),
             kwargs={'song': '凉凉'}, name='happy')

t.start()
t.join()

同步互斥

线程间通信方法

1. 通信方法
   线程间使用全局变量进行通信。
2. 共享资源争夺

• 共享资源：多个进程或者线程都可以操作的资源称为共享资源。对共享资源的操作代码段称为临界区。
• 影响 ： 对共享资源的无序操作可能会带来数据的混乱，或者操作错误。此时往往需要同步互斥机制协调操作顺序。

3. 同步互斥机制
   同步 ： 同步是一种协作关系，为完成操作，多进程或者线程间形成一种协调，按照必要的步骤有序执行操作。
   
   互斥 ： 互斥是一种制约关系，当一个进程或者线程占有资源时会进行加锁处理，此时其他进程线程就无法操作该资源，直到解锁后才能操作。
   

线程同步互斥方法

线程Event

from threading import Event

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

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

e.set()  设置e，使wait结束阻塞(没有这句话e.wait()一直堵塞)

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

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

重点代码：

from threading import Thread, Event

s = None  # 全局变量用于通信
e = Event()

def yang():
    print("杨子荣前来拜山头")
    global s
    s = "天王盖地虎"
    e.set()  # 共享资源操作完毕

t = Thread(target=yang)
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:  上锁
...
...
	 with代码块结束自动解锁

重点代码：

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. 死锁的产生原因：

简单来说造成死锁的原因可以概括成三句话：

• 当前线程拥有其他线程需要的资源
• 当前线程等待其他线程已拥有的资源
• 都不放弃自己拥有的资源

4. 如何避免死锁

死锁是我们非常不愿意看到的一种现象，我们要尽可能避免死锁的情况发生。通过设置某些限制条件，去破坏产生死锁的四个必要条件中的一个或者几个，来预防发生死锁。预防死锁是一种较易实现的方法。但是由于所施加的限制条件往往太严格，可能会导致系统资源利用率。

• 使用定时锁
• 使用重载锁RLock()，用法同Lock。RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次acquire。直到一个线程所有的acquire都被release，其他的线程才能获得资源。

使用定时锁：

import time
import threading

# 交易类
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, threading.Lock())
Alex = Account('Alex', 8000, threading.Lock())


# 转账函数
def transfer(from_, to, amount):
    if from_.lock.acquire():  # 锁自己账户
        from_.withdraw(amount)  # 自己账户减少
        time.sleep(0.5)  # 产生死锁（因为from和to同时上锁）
        if to.lock.acquire():  # 对方账户上锁
            to.deposit(amount)
            to.lock.release()  # 对方账户解锁
        from_.lock.release()  # 自己账户解锁
    print("%s 给 %s转账完成" % (from_.id, to.id))

t1 = threading.Thread(target=transfer,
                      args=(Tom, Alex, 2000))
t2 = threading.Thread(target=transfer,
                      args=(Alex, Tom, 2000))
t1.start()
time.sleep(2)  # t2等待一段时间再上锁，确保t1先执行完
t2.start()
t1.join()
t2.join()

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

使用重载锁RLock()：

from threading import Thread, RLock
import time

num = 0  # 共享资源
lock = RLock()  # 在一个线程内可以对锁进行重复加锁

class MyThread(Thread):
    def fun1(self):
        global num
        with lock:
            num -= 1

    def fun2(self):
        global num
        if lock.acquire():
            num += 1
            if num > 5:
                self.fun1()
            print("Num=", num)
            lock.release()

    def run(self):
        while True:
            time.sleep(2)
            self.fun2()

t = MyThread()
t.start()
t.join()

Python线程GIL

简单来说，就是利用python实现线程的效率低

1. python线程的GIL问题（全局解释器锁）

什么是GIL ：由于python解释器设计中加入了解释器锁，导致python解释器同一时刻只能解释执行一个线程，大大降低了线程的执行效率。
导致后果： 因为遇到阻塞时线程会主动让出解释器，去解释其他线程。所以python多线程在执行多阻塞高延迟IO时可以提升程序效率，其他情况并不能对效率有所提升。

GIL问题建议：

• 尽量使用进程完成无阻塞的并发行为
• 不使用c作为解释器 （Java C#）

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

作业：编写程序完成效率测试

• 使用单线程执行计算密集函数十次记录时间，执行IO密集函数十次记录时间
• 使用10个线程分别执行计算密集函数1次记录时间，执行IO密集函数1次记录时间
• 使用10个进程分别执行计算密集函数1次记录时间，执行IO密集函数1次记录时间

计算密集型函数：

def count(x,y):
	c = 0
	while c < 7000000:
		c += 1
		x += 1
		y += 1

IO密集型函数：

def io():
	write()
	read()

def write():
	f = open('test','w')
	for i in range(1500000):
		f.write("hello world\n")
	f.close()

def read():
	f = open('test')
	lines = f.readlines()
	f.close()	

---

• 【单线程】计算密集函数十次：8.780869245529175；IO密集型函数十次：4.685685396194458
• 【多线程】计算密集函数十次：14.451507091522217；IO密集型函数十次：6.815863847732544
• 【多进程】计算密集函数十次：4.909349203109741；IO密集型函数十次：2.378950357437134

测试代码

进程线程的区别联系

区别联系

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

使用场景

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

要求

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