2022 Python寒假级高培训 第三次 笔记

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

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

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

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

创建多线程 例子：

import threading        #导包
import time


def test(x):
    print(x)
    time.sleep(2)
# test(1)
# test(2)
# #第一种创建线程的方法
# t1 = threading.Thread(target=test,args=(1,))
#                         #方法名        #参数
# t2 = threading.Thread(target=test,args=(2,))
#                         #方法名           #参数
# t1.start()
# t2.start()

#第二种创建线程的方法 创建类
class MyTheard(threading.Thread):
    def __init__(self,n):
        super(MyTheard, self).__init__()
        self.n = n

    def run(self):
        print("以类的方式创建多线程，self.n")

r1 = MyTheard(11)        #创建一个线程
r2 = MyTheard(22)
r1.start()       #启动线程         
r2.start()

多线程的特性

1.        t.setDaemon(True) #设置守护线程:等待其他线程结束再结束  或者提前与其他线程一起结束

2.        t1.join() #调用join函数 作用：等到t1线程结束才启动其他线程

3.        print(threading.active_count()) #打印活动线程个数

4.        threading.current_thread() 查看当前线程 调用该方法的线程

例子：

"""多线程的特性"""
import threading
import time

def run(x,n):
    print(f"线程{x}")
    time.sleep(n)

if __name__=='__main__':
    # 1970年到现在共走了多少秒
    # print(time.time())
    start_time = time.time()
    res = []
    for i in range(10):
        if i == 9:
            i = 2
        t = threading. Thread(target=run,args=(i,i))
        t.setDaemon(True)    #设置守护线程:等待其他线程结束再结束
                                        # 或者提前与其他线程一起结束
        t.start()
        res.append(t)
    print(threading.active_count())
    for t in res:
        t.join()
    # run(1)
    # run(2)
    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()       #调用join函数 作用：等到t1线程结束才启动其他线程
# t2.start()

    #查看活动的线程
    #threading.active_count()
    print(threading.active_count()) #打印活动线程个数
    # threading.current_thread() 查看当前线程 调用该方法的线程

三、线程锁

lock = threading.Lock() #创建线程锁：线程锁内代码只能一个线程同时执行

'''线程锁'''
import threading
def run():
    global x #修改全局变量
    lock.acquire()  #申请线程锁
    x+=1
    lock.release()  #释放线程锁

if __name__ == '__main__':
    x = 0
    res = []    #创建列表
    lock = threading.Lock()     #创建线程锁
    for i in range(100):
        t = threading.Thread(target=run)
        t.start()
        res.append(t) #把线程装到列表中

    for t in res:   #遍历列表
        t.join()    #等待上一个线程结束再调用启动下一个线程

    print(x)

当出现线程锁套线程锁的情况，用递归锁RLock
'''递归锁'''
#递归锁：RLock
import threading
def run1():
    global x
    lock.acquire()  #锁2
    x+= 1
    lock.release()  #锁2
    return x
def run2():
    global  y
    lock.acquire()
    y+= 1
    lock.release()
    return y
def run3():
    lock.acquire()  #锁1
    res1 = run1()
    res2 = run2()
    lock.release()  #锁1
    print(res1,res2)

if __name__ == '__main__':
    x = 0
    y = 0
    lock = threading.RLock()       #锁里嵌套锁 要用RLock
    for i in range(3):
        t = threading.Thread(target=run3)
        t.start()

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

    print('线程结束')

获取当前时间并打印
import time
print (time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))

python时间与日期：
https://www.runoob.com/python/python-date-time.html

python学习视频
https://space.bilibili.com/196858266/video