python线程（二）代码部分Threading模块

一、threading类简介

1、threading.Thread类参数简介

class threading.Thread(group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None)

group：目前此参数为None，在实现ThreadGroup类时为将来的扩展保留。

target：target接收的是一个函数的地址，由run()方法调用执行函数中的内容。默认为无，表示未调用任何内容。

name ：线程名，可自行定义。

args：target接收的是函数名，此函数的位置参数以元组的形式存放在args中，用于执行函数时调用。

kwargs ：target接收的是函数名，此函数的关键字参数以字典的形式存放在kwargs中，用于执行函数时调用。

daemon：如果为True表示该线程为守护线程。

2、threading.Thread类的常用方法

start()：开启线程，一个Thread对象只能调用一次start()方法，如果在同一线程对象上多次调用此方法，则会引发RuntimeError。

run()：执行start()方法会调用run()，该方将创建Thread对象时传递给target的函数名，和传递给args、kwargs的参数组合成一个完整的函数，并执行该函数。run()方法一般在自定义Thead类时会用到。

join(timeout=None)：join会阻塞、等待线程，timeout单位为秒，因为join（）总是返回none，所以在设置timeout调用join（timeout）之后，需要使用isalive（）判断线程是否执行完成，如果isalive为True表示线程在规定时间内没有执行完，线程超时。如果join(timeout=None)则会等待线程执行完毕后才会执行join（）后面的代码，一般用于等待线程结束。

name：获取线程名。

getName()：获取线程名。

setName(name)：设置线程名。

ident：“线程标识符”，如果线程尚未启动，则为None。如果线程启动是一个非零整数。

is_alive()：判断线程的存活状态，在run（）方法开始之前，直到run（）方法终止之后。如果线程存活返回True，否则返回False。

daemon：如果thread.daemon=True表示该线程为守护线程，必须在调用Start（）之前设置此项，否则将引发RuntimeError。默认为False

isDaemon()：判断一个线程是否是守护线程。

setDaemon(daemonic)：设置线程为守护线程。

二、threading.Thread的简单使用

创建线程：

from threading import Thread

def work(args,kwargs=None):
    print(args)
    print(kwargs)

if __name__ == "__main__":
    t = Thread(target=work, args=(("我是位置参数"),), kwargs={'kwargs': '我是关键字参数'}, name='我是线程demo')
    print(t.name)  # 打印线程名
    t.start()          # 开启线程
    print('我是主线程')

# 打印内容如下
我是线程demo
我是位置参数
我是关键字参数
我是主线程

由上面的打印内容我们可以看出，在执行完所有线程后才执行的主线程print。如果是多进程的话会先执行主进程中的print然后才会执行子进程的print。主要是因为开启进程相比于开启线程更加耗费时间。

自定义线程类

from threading import Thread

def work(args,kwargs=None):
    print(args)
    print(kwargs)
class MyThread(Thread):  # 使用继承Thread的方式，自定义线程类
    def __init__(self,target=None, name=None,
                 args=(), kwargs=None, *, daemon=None):
        # 如果要给对象封装属性，必须先调用父类
        super().__init__()
        if kwargs is None:
            kwargs = {}
        self._target = target
        self._name = name
        self._args = args
        self._kwargs = kwargs
    def run(self):  # 必须要有run类，因为start要调用
        print(f"我重写了Thread类的run")
        self._target(*self._args,**self._kwargs)

if __name__ == "__main__":

    t = MyThread(target=work,args=(('我是位置参数'),),kwargs={'kwargs':'我是关键字参数'},name='我是自定义线程类') # 创建线程对象
    print(t.name)  # 打印线程名
    t.start()      # 开启线程
    print("主线程")

# 打印内容如下
我是自定义线程类
我重写了Thread类的run
主线程
我是位置参数
我是关键字参数

多进程和多线程的效率对比

from threading import Thread
from multiprocessing import Process
import time

def thread_work(name):
    print(f"{name}")
def process_work(name):
    print(f"{name}")

if __name__ == "__main__":
    # 进程执行效率
    pro = []
    start = time.time()
    for i in range(3):
        p = Process(target=process_work,args=(("进程-"+str(i)),))
        p.start()
        pro.append(p)
    for i in pro:
        i.join()
    end = time.time()
    print("进程运行了:%s" %(end - start))
    # 线程执行效率
    thread_l = []
    start = time.time()
    for i in range(3):
        t = Thread(target=process_work, args=(("线程-" + str(i)),))
        t.start()
        thread_l.append(t)
    for i in thread_l:
        i.join()
    end = time.time()
    print("进程运行了:%s" % (end - start))

# 打印内容如下
进程-0
进程-1
进程-2
进程运行了:0.18501067161560059
线程-0
线程-1
线程-2
进程运行了:0.004000186920166016

我们可以从时间上看出，线程的效率是远远高于进程的。

守护线程

主线程会等待所有非守护线程执行完毕后，才结束主线程。主进程是进程内的代码结束后就结束主进程。

对比守护进程，代码执行完毕后立即关闭守护进程，因为在主进程看来代码执行完毕，主进程结束了，所以守护进程在代码结束后就被结束了。

守护线程会等待主线程的结束而结束。这是因为如果主线程结束意味着程序结束，主线程会一直等着所有非守护线程结束，回收资源然后退出程序，所以当所有非守护线程结束后，守护线程结束，然后主线程回收资源，结束程序。

下面对比守护进程和守护线程的示例：

先来看守护进程：

from multiprocessing import Process

def process_work(name):
    print(f"{name}")

if __name__ == "__main__":
    p = Process(target=process_work,args=("守护进程"))
    p.daemon=True
    p.start()
    print("主进程")

# 打印内容如下
主进程

只打印了主进程，也就是说守护进程还没来得及执行程序就结束了。

再来看守护线程：

from threading import Thread

def thread_work(name):
    print(name)

if __name__ == "__main__":
    t = Thread(target=thread_work,args=("守护线程",))
    t.daemo=True
    t.start()
    print("n主线程")

# 打印内容如下
守护线程
主线程

也许你会说是由于线程太快了，所以才执行了守护线程。下面我们在线程中阻塞一段时间，在来看看会发生什么效果。

from threading import Thread
import time
def thread_work(name):
    time.sleep(3)  # 阻塞3秒
    print(name)

if __name__ == "__main__":
    t = Thread(target=thread_work,args=("守护线程",))
    t.daemo=True
    t.start()
    print("n主线程")

# 打印内容如下
主线程
守护线程

守护线程还是被执行了，如果是守护进程，守护进程里的代码是不会被执行的。

线程锁Lock

Lock也称线程同步锁，互斥锁，原子锁，该对象只有两个方法：

acquire(blocking=True, timeout=-1)：加锁。

参数：

blocking：当为True时表示加锁，只允许一个线程执行被加锁的代码。直到遇到release()解锁后其它线程才可以执行加锁部分的代码。当为False时表示不加锁，并且不能调用release()否则会报RuntimeError。

timeout：设置加锁时间，单位为秒。-1表示一直等待线程release()后，才允许其它线程执行加锁的代码。

release()：释放锁。

未加锁的代码示例

from threading import Thread
import time

def work():
    global n
    temp = n
    time.sleep(0.1)  # 由于线程太快了，所以这里停顿下
    n = temp -1

if __name__ == "__main__":
    n = 100
    t_l = []
    for i in range(100):
        t = Thread(target=work,args=())
        t.start()
        t_l.append(t)
    for i in t_l:
        i.join()
    print(n)

# 打印内容如下
99

在我们看来其实值应该是0的但却是99，就因为短暂停了0.1秒导致结果发生了变化。而我们这0.1秒的停留是模拟网络延迟或者进程调度等原因。造成了数据的结果的错乱。这个时候我们就需要线程锁来保证数据的安全性。

下面我们就通过给程序加锁，来保证数据的安全性：

from threading import Thread,Lock
import time

def work(lock):
    lock.acquire()  # 加锁
    global n
    temp = n
    time.sleep(0.1)  # 由于线程太快了，所以这里停顿下
    n = temp -1
    lock.release()  # 解锁

if __name__ == "__main__":
    n = 100
    t_l = []
    lock = Lock()  # 得到一把锁对象
    for i in range(100):
        t = Thread(target=work,args=(lock,))
        t.start()
        t_l.append(t)
    for i in t_l:
        i.join()
    print(n)

# 打印内容如下
0

我们会发现程序和上一个示例的运行效率上有着很大的差别。明显加锁后程序的运行效率降低了，我们管这种锁叫做线程同步锁，使原本并行的程序编程了串行所以程序的效率会慢很多，但是程序的运行结果是正确的。在程序的运行效率和数据的正确性，我们应首先确保程序的正确性然后在考虑程序的效率。

递归锁RLock

死锁与递归锁：

所谓死锁：是指两个或两个以上的进程或线程在执行过程中，出现了一种互相等待的情况，它们都将无法进行下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程，如下模拟产生死锁。

from threading import Lock,Thread

def work():
    # 获取锁
    lock.acquire()
    print("我是工作线程 1")
    # 释放锁
    lock.release()

def work_2():
    # 获取锁
    lock.acquire()
    print("我是工作线程 2")
    work()  # 调用工作线程1，造成死锁
    # 释放锁
    lock.release()

if __name__ == '__main__':
    # 生成lock实例
    lock = Lock()
    # 开始3个线程
    for i in range(3):
        t = Thread(target=work_2)
        t.start()
    print('我是主线程')

# 打印内容如下
我是主线程
我是工作线程 2  # 此时程序处于死锁状态

我们可以理解为一把锁对象只能创建一把锁，这把锁必须release后，才能再次使用。否则程序就会被锁住，等待解锁。如上面的代码，work_2执行创建一个lock锁，调用work又遇到一把lock锁，而在work_2中的lock锁没有被解锁，所以程序在work中等待lock解锁，最终造成了程序出现了死锁，下面我们使用递归锁RLock来解决上面的问题。

关于RLock的用法及方法一样，所以这里就不再重复了。

使用RLock避免死锁：

from threading import RLock,Thread

def work():
    # 获取锁
    lock.acquire()
    print("我是工作线程 1")
    # 释放锁
    lock.release()

def work_2():
    # 获取锁
    lock.acquire()
    print("我是工作线程 2")
    work()  # 调用工作线程1，造成死锁
    # 释放锁
    lock.release()

if __name__ == '__main__':
    # 使用递归锁RLock
    lock = RLock()
    # 开始3个线程
    for i in range(3):
        t = Thread(target=work_2)
        t.start()
    print('我是主线程')

# 打印内容如下
我是工作线程 2
我是工作线程 1
我是工作线程 2
我是工作线程 1
我是工作线程 2
我是主线程
我是工作线程 1

使用递归锁后程序运行正常了。

条件对象Condition(lock=None)

1、Condition类的方法

class threading.Condition([lock])

acquire()：加锁、与Lock、RLock中的用法一致，这里不过多解释。

release()：解锁、与Lock、RLock中的用法一致，这里不过多解释。

wait(timeout=None)：挂起线程，如果timeout是None则必须等到notify或notify_all后线程才会被激活，并且被激活的线程会重新获取到一把锁，线程被激活后从wait挂起的位置继续向下执行。如果指定timeout超时时间，单位为秒，表示线程挂起一段时间后在继续执行。注意：如果调用线程在调用此方法时未获取锁，则会引发RuntimeError。

wait_for(predicate, timeout=None)：这个不知道该如何解释。

notify(n=1)：激活被挂起的线程，n表示激活n个被挂起的线程，注意：如果调用线程在调用此方法时未获取锁，则会引发RuntimeError。

notify_all()：激活所有被挂起的线程，注意：如果调用线程在调用此方法时未获取锁，则会引发RuntimeError。。

2、下面是一个无聊的实例：

from threading import Condition,Thread
import time

def consume():
    '''消费者'''
    global cv
    global num
    cv.acquire()
    while True:
        num -= 1
        if num <= 0:
            print('-' * 20)
            cv.notify()  # 激活生产者线程
            cv.wait()
        print(f'消费数据-{num}')
        time.sleep(2)
    cv.release()

def produce():
    '''生产者'''
    global cv
    global num
    cv.acquire()
    while 1:
        num += 1
        print(f'生产数据-{num}')
        if num >= 5:
            print('-' * 20)
            cv.notify()  # 激活消费者线程
            cv.wait()
        time.sleep(0.5)
    cv.release()

if __name__ == '__main__':
    cv = Condition()   # 实例化条件对象
    num = 0
    # 开启线程
    produce_t = Thread(target=produce, args=())
    consume_t = Thread(target=consume, args=())
    produce_t.start()
    consume_t.start()

Threading类的方法：

threading.active_count()：获取当前活动的线程对象数量。

threading.current_thread()：获取当前的线程对象。如果调用方的控制线程不是通过线程模块创建的，则返回功能有限的虚拟线程对象。

threading.get_ident()：获取线程标识符。

threading.enumerate()：这个比较厉害，可以获取当前活动的所有线程对象的列表。该列表包括后台线程和使用current_thread()创建的虚拟线程。以列表的形式返回。

threading.main_thread()：获取主线程对象。

Threading模块就简单介绍到这里吧，参考文档：https://docs.python.org/3/library/threading.html#threading.Condition.notify

文章出自 https://www.cnblogs.com/caesar-id/archive/2019/04/24/10764710.html