Python深度培训笔记三

目录

一、多线程

二、多线程特性

三、线程锁-互斥锁

四、线程锁-递归锁

---

一、多线程

1.线程是程序执行的最小单位，而进程是操作系统分配资源的最小单位；

2.一个进程由一个或多个线程组成，线程是一个进程中代码的不同执行路线；

3.线程之间相互独立，但同一进程下的各个线程之间共享程序的内存空间（包括代码段、数据集、堆等）及一些进程及的资源（如打开文件和信号等），某进程内的线程在其他进程不可见；

4.调度和切换：线程上下文切换比进程上下文切换要快得多。

案例：

#多线程

#创建多线程

# import time
# import threading

# #方式一
# def test(x):
#     print(x)
#     time.sleep(2)
#

#     t1 = threading.Thread(target=test, args=(1,))
#     t2 = threading.Thread(target=test, args=(2,))
#
#     t1.start()
#     t2.start()

#方式二：以类的方式创建
import threading
import time

class myThread(threading.Thread): #继承父类threading.Thread
    def __init__(self,n):
        super(myThread, self).__init__()
        self.n=n
    def run(self):  #run函数必须调用
        print('以类的方式创建多线程',self.n)
        time.sleep(2)



r1=myThread(1)
r2=myThread(2)
r1.start()
r2.start()

二、多线程特性

查看当前线程：threading.current_thread()
查看活动的线程：threading.active_count()
time模块与时间戳和时间相关的重要函数
time.time() 生成当前的时间戳，格式为10位整数的浮点数。
time.strftime()根据时间元组生成时间格式化字符串。
time.strptime()根据时间格式化字符串生成时间元组。time.strptime()time.strftime()为互操作。
time.localtime()根据时间戳生成当前时区的时间元组。
 

案例：

import threading
import time
def run(x):
    print(f"线程{x}")
    time.sleep(2)
    print(threading.current_thread())

if __name__ == '__main__': #主线程
    start_time=time.time()
    res=[]
    for i in range(50):
        #if i==9:
        #    i=2
        t=threading.Thread(target=run,args=(i,))
        t.setDaemon(True)
        t.start()
        res.append(t)

    #查看活动的线程
    print(threading.active_count())

    print(f"run()函数共运行了{time.time()-start_time}秒")

    t1 = threading.Thread(target=run,args=(1,))
    t2 = threading.Thread(target=run, args=(2,))
    t1.start()
    t1.join()#等待第一个线程执行完后再开始另一个线程
    t2.start()



    #查看当前线程
    print(threading.current_thread())

三、线程锁-互斥锁

案例：

#线程锁


#互斥锁
import threading
def run():
    global x
    lock.acquire() #申请一把锁
    x+=1 #每起一个线程，x就会加1.最后为100
    lock.release() #释放锁

if __name__=='__main__':
    x=0
    res=[]
    lock=threading.Lock() #实例化线程锁
    for i in range(100): #100个线程
        t=threading.Thread(target=run)
        t.start()
        res.append(t)
    for t in res:
        t.join() #设置主线程等待子线程结束.主线程一直等待全部的子线程结束之后，主线程自身才结束
    print(x)

四、线程锁-递归锁

案例：

#递归锁 RLcok

# 用法和Lock相同，但它支持嵌套，在多个锁没有释放的时候一般使用RLock类

import threading

def run1():
    global x
    lock.acquire()
    x+=1
    lock.release()
    return x
def run2():
    global y
    lock.acquire()
    y+=1
    lock.release()
    return y
def run3():
    lock.acquire()
    res1=run1()
    res2=run2()
    lock.release()
    print(res1,res2)

if __name__=='__main__':
    x=0
    y=0
    lock=threading.RLock()
    for i in range(50):
        t=threading.Thread(target=run3)
        t.start()

    while threading.active_count() !=1:
        print(f'正在运行{threading.active_count()}+个线程')

    print("程序运行结束")