python之路--关于线程的一些方法

Posted 2021-02-02 一个很善良的抱爱

一 . 线程的两种创建方式

from threading import Thread
# 第一种创建方式
def f1(n):
    print(\'%s号线程任务\'%n)
def f2(n):
    print(\'%s号线程任务\'%n)
if __name__ == \'__main__\':
    t1 = Thread(target=f1,args=(1,))
    t2 = Thread(target=f2,args=(2,))
    t1.start()
    t2.start()
    print(\'主线程\')
# 第二种创建方式
class MyThread(Thread):
    def __init__(self,name):
        # super(MyThread, self).__init__()  和下面super是一样的
        super().__init__()
        self.name = name
    def run(self):
        print(\'hello girl :\' + self.name)
if __name__ == \'__main__\':
    t = MyThread(\'alex\')
    t.start()
    print(\'主线程结束\')

 

二 . 查看线程的pid

import os
from threading import Thread
def f1(n):
    print(\'1号=>\',os.getpid())
    print(\'%s号线程任务\' % n)
def f2(n):
    print(\'2号=>\',os.getpid())
    print(\'%s号线程任务\' % n)
if __name__ == \'__main__\':
    t1 = Thread(target=f1,args=(1,))
    t2 = Thread(target=f2,args=(2,))
    t1.start()
    t2.start()
    print(\'主线程\', os.getpid())
    print(\'主线程\')
    
# 由于这些线程都是在一个进程中的,所以pid一致

 

三 .  验证线程之间的数据共享

import time
from threading import Thread
num = 100
def f1(n):
    global num
    num = 3
    time.sleep(1)
    print(\'子线程的num\', num)  # 子线程的num 3
if __name__ == \'__main__\':
    thread = Thread(target=f1,args=(1,))
    thread.start()
    thread.join() # 等待thread执行完在执行下面的代码
    print(\'主线程的num\', num)  # 主线程的num 3

 

四. 多进程与多线程的效率对比

import time
from threading import Thread
from multiprocessing import Process
def f1():
    # io密集型
    # time.sleep(1)

    # 计算型:
    n = 10
    for i in range(10000000):
        n = n + i
if __name__ == \'__main__\':
    #查看一下20个线程执行20个任务的执行时间
    t_s_time = time.time()
    t_list = []
    for i in range(5):
        t = Thread(target=f1,)
        t.start()
        t_list.append(t)
    [tt.join() for tt in t_list]
    t_e_time = time.time()
    t_dif_time = t_e_time - t_s_time
    #查看一下20个进程执行同样的任务的执行时间
    p_s_time = time.time()
    p_list = []
    for i in range(5):
        p = Process(target=f1,)
        p.start()
        p_list.append(p)
    [pp.join() for pp in p_list]
    p_e_time = time.time()
    p_dif_time = p_e_time - p_s_time
    # print(\'多线程的IO密集型执行时间:\',t_dif_time)  # 1.0017869472503662 还需要减1秒的time.sleep
    # print(\'多进程的IO密集型执行时间:\',p_dif_time)  # 1.2237937450408936  也需要减1秒的time.sleep

    print(\'多线程的计算密集型执行时间:\', t_dif_time)  # 3.58754563331604
    print(\'多进程的计算密集型执行时间:\', p_dif_time)  # 2.1555309295654297

 

　　# 从上述代码中的执行效率可以看出来,多线程在执行IO密集型的程序的时候速度非常快,但是执行计算密集型的程序的时候很慢,所以说python这门语言不适合做大数据. 

五 . 互斥锁,同步锁

import time
from threading import Lock, Thread
num = 100
def f1(loc):
    # 加锁
    with loc:
        global num
        tmp = num
        tmp -= 1
        time.sleep(0.001)
        num = tmp
        # 上面的代码相当于 num -= 1 
if __name__ == \'__main__\':
    t_loc = Lock()
    t_list = []
    for i in range(10):
        t = Thread(target=f1,args=(t_loc,))
        t.start()
        t_list.append(t)
    [tt.join() for tt in t_list]
    print(\'主线的num\',num)

 

六 . 死锁现象

import time
from threading import Thread,Lock,RLock
def f1(locA,locB):
    locA.acquire()
    print(\'f1>>1号抢到了A锁\')
    time.sleep(1)
    locB.acquire()
    print(\'f1>>1号抢到了B锁\')
    locB.release()
    locA.release()
def f2(locA,locB):
    locB.acquire()
    print(\'f2>>2号抢到了B锁\')
    time.sleep(1)
    locA.acquire()
    print(\'f2>>2号抢到了A锁\')
    locA.release()
    locB.release()
if __name__ == \'__main__\':
    # locA = locB = Lock()  # 不能这么写,这么写相当于这两个是同一把锁
    locA = Lock()
    locB = Lock()
    t1 = Thread(target=f1,args=(locA,locB))
    t2 = Thread(target=f2,args=(locA,locB))
    t1.start()
    t2.start()
# 上面的代码表示f1 先抢到了A锁,同时f2 抢到了B锁,一秒后f1想去想B锁,同时f2想去抢A锁,
# 由于锁需要先放开才能继续抢,导致了死锁现象　

七.递归锁

import time
from threading import Thread, Lock, RLock
def f1(locA, locB):
    locA.acquire()
    print(\'f1>>1号抢到了A锁\')
    time.sleep(1)
    locB.acquire()
    print(\'f1>>1号抢到了B锁\')
    locB.release()
    locA.release()
def f2(locA, locB):
    locB.acquire()
    print(\'f2>>2号抢到了B锁\')
    locA.acquire()
    time.sleep(1)
    print(\'f2>>2号抢到了A锁\')
    locA.release()
    locB.release()
if __name__ == \'__main__\':
    locA = locB = RLock()  #递归锁,维护一个计数器,acquire一次就加1,release就减1 , acquire等于0的时候才可以抢
    t1 = Thread(target=f1, args=(locA, locB))
    t2 = Thread(target=f2, args=(locA, locB))
    t1.start()
    t2.start()

 

　 # 递归锁解决了死锁现象,会让代码继续执行.

八. 守护线程

　　守护线程会等到所有的非守护线程运行结束后才结束

import time
from threading import Thread
from multiprocessing import Process

#守护进程:主进程代码执行运行结束,守护进程随之结束

#守护线程:守护线程会等待所有非守护线程运行结束才结束

def f1():
    time.sleep(2)
    print(\'1号线程\')
def f2():
    time.sleep(3)
    print(\'2号线程\')
if __name__ == \'__main__\':
    t1 = Thread(target=f1,)
    t2 = Thread(target=f2,)
    # t1.daemon = True  # 1号进程 和 2 号进程都会打印
    t2.daemon = True # 不会打印2号进程
    t1.start()
    t2.start()
    print(\'主线程结束\')
    # 与进程对比
    p1 = Process(target=f1, )
    p2 = Process(target=f2, )
    p1.daemon = True  # 只会打印 2号进程
    p2.daemon = True  # 只会打印1号进程
    p1.start()
    p2.start()
    print(\'主进程结束\')

 

九 . GIL锁的解释