python-threading

作者 by Joab / 2022-04-14 / 暂无评论 / 34 个足迹

Thread实例对象的方法
  # isAlive(): 返回线程是否活动的。
  # getName(): 返回线程名。
  # setName(): 设置线程名。

threading模块提供的一些方法:
  # threading.currentThread(): 返回当前的线程变量。
  # threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前,不包括启动前和终止后的线程。
  # threading.activeCount(): 返回正在运行的线程数量,与len(threading.enumerate())有相同的结果。

开启线程的方式

# 开启线程的方式一
from threading import Thread


def task(s1):
    print("线程开启了")


if __name__ == '__main__':
    s1 = '线程开启了'
    # args可迭代对象元组只有一个参数的情况需要加","
    p = Thread(target=task, args=(s1,))
    p.start()

# 开启线程的方式二,继承Thread类重新run方法
from threading import Thread


class Task2(Thread):
    def __init__(self, name):
        super().__init__()
        self.name = name

    def run(self):
        # print(self.name)
        print("牛逼")


if __name__ == '__main__':
    t = Task2("Joab")
    t.start()

在主进程下开启进程和线程谁的速度快

import time
from threading import Thread
from multiprocessing import Process
import os


def work():
    time.sleep(2)
    print('hello')


if __name__ == '__main__':
    # 在主进程下开启线程
    start_t = time.time()
    t = Thread(target=work)
    t.start()
    t.join()
    print('主进程开启线程')
    print(time.time() - start_t)
    
    # 在主进程下开启子进程
    start_t = time.time()
    t = Process(target=work)
    t.start()
    t.join()
    print('主进程开启进程')
    print(time.time() - start_t)
    
# 输出
hello
主进程开启线程
2.021684408187866

hello
主进程开启进程
2.234938383102417

# 结论
开启线程速度更快,资源占用小

守护线程

无论是进程还是线程,都遵循:守护xxx会等待主xxx运行完毕后被销毁

from threading import Thread
import time


def sayhi(name):
    print('%s say hello' % name)
    time.sleep(2)


if __name__ == '__main__':
    t = Thread(target=sayhi, args=('Joab',))
    # 声明是守护线程,而不是t.Daemon = True
    t.setDaemon(True)  # 必须在t.start()之前设置
    t.start()
    # 开启的线程是否存活
    print(t.is_alive())
# 输出,因为打印改结果时候主进程未关闭,所以守护线程存活是True
Joab say hello
True

线程锁

三个需要注意的点:
#1.线程抢的是GIL锁,GIL锁相当于执行权限,拿到执行权限后才能拿到互斥锁Lock,其他线程也可以抢到GIL,但如果发现Lock仍然没有被释放则阻塞,即便是拿到执行权限GIL也要立刻交出来

#2.join是等待所有,即整体串行,而锁只是锁住修改共享数据的部分,即部分串行,要想保证数据安全的根本原理在于让并发变成串行,join与互斥锁都可以实现,毫无疑问,互斥锁的部分串行效率要更高

#3. 一定要看本小节最后的GIL与互斥锁的经典分析
from threading import Thread, Lock
import os, time


def work():
    global n
    # 公共数据的操作加锁
    lock.acquire()
    temp = n
    time.sleep(0.1)
    n = temp - 1
    lock.release()


if __name__ == '__main__':
    lock = Lock()
    n = 100
    l = []
    for i in range(100):
        p = Thread(target=work)
        l.append(p)
        p.start()
    for p in l:
        p.join()

    print(n)  # 结果肯定为0,由原来的并发执行变成串行,牺牲了执行效率保证了数据安全

死锁现象与递归锁

所谓死锁: 是指两个或两个以上的进程或线程在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力作用,它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁,这些永远在互相等待的进程称为死锁进程,如下就是死锁

from threading import Thread, Lock
import time

mutexA = Lock()
mutexB = Lock()


class MyThread(Thread):
    def run(self):
        self.func1()
        self.func2()

    def func1(self):
        mutexA.acquire()
        print('%s 拿到A锁' % self.name)

        mutexB.acquire()
        print('%s 拿到B锁' % self.name)
        mutexB.release()

        mutexA.release()

    def func2(self):
        mutexB.acquire()
        print('%s 拿到B锁' % self.name)
        time.sleep(2)

        mutexA.acquire()
        print('%s 拿到A锁' % self.name)
        mutexA.release()

        mutexB.release()


if __name__ == '__main__':
    for i in range(10):
        t = MyThread()
        t.start()

解决方法,递归锁,在Python中为了支持在同一线程中多次请求同一资源,python提供了可重入锁RLock。

这个RLock内部维护着一个Lock和一个counter变量,counter记录了acquire的次数,从而使得资源可以被多次require。直到一个线程所有的acquire都被release,其他的线程才能获得资源。上面的例子如果使用RLock代替Lock,则不会发生死锁:

#一个线程拿到锁,counter加1,该线程内又碰到加锁的情况,则counter继续加1,这期间所有其他线程都只能等待,等待该线程释放所有锁,即counter递减到0为止
mutexA=mutexB=threading.RLock() 

独特见解