Python高级学习第三课（寒假） 2022-1-6

Python高级学习第三课（寒假） 2022-1-6

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

一个大的运行程序相当于一个进程一个进程由一个或多个线程组成，线程是一个进程中代码的不同执行路线进程之间相互独立，但同一进程下的各个线程之间共享程序的内存空间(包括代码段，数据集，堆等)及一些进程级的资源(如打开文件和信号等)，某进程内的线程在其他进程不可见调度和切换:线程上下文切换比过程上下文切换要快得多
 程序下不同的线路即线程

创建线程

# 导入头文件
import threading
# 创建线程
t1 = threading.Thread(target=name) # 函数名，接口，无括号
# 如有参数, 元组的形式
t1 = threading.Thread(target=name, args=(1, ))

启动线程

t1.start()

使用类的方式实现多线程

# 导入头文件
import threading
import time

# 继承threading
class Thread_1(threading.Thread):
    def __init__(self,name):
        super(Thread_1, self).__init__()
        self.name = name

    def run(self): # 重写，必须用run函数
        while 1:
            print(self.name)
            time.sleep(1)

class Thread_2(threading.Thread):
    def __init__(self,cat):
        super(Thread_2, self).__init__()
        self.cat = cat

    def run(self): # 重写
        while 1:
            print(self.cat)
            time.sleep(3)
# 定义实例对象
t1 = Thread_1("张三")
t2 = Thread_2("cat")
t1.start()
t2.start()

延时函数，括号中为要延时的时间（s）

import time
time.sleep()

线程锁

如用线程进行x的+1递归（在python2中常会出现这种情况）

可能会出现两个线程同时运行进行x值的增加，会导致最后结果少1

import threading

def run():
    global x   # 全局变量
    x += 1

if __name__ == '__main__':
    x = 0
    res = []
    for i in range(100):
        t = threading.Thread(target=run)
        t.start()
        res.append(t)

    for t in res:
        t.join()

    print(x)

加一个线程锁杜绝这种现象，将值锁起来，禁止其他线程 *** 作，释放后才可 *** 作

'''保证每次只有一个线程进行 *** 作'''
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)

递归锁

嵌套的流程锁会互相锁死，反复循环

将嵌套的流程锁改为递归锁杜绝此现象

lock = threading.RLock()

多线程特性

从1970年至现在走了多少秒

time.time()

让t1线程运行完再运行t2线程，在二者间加 t1.join()，并非wait函数查看线程运行时间（整体8s的）

import threading
import time

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

if __name__ == '__main__':
    start_time = time.time()  # 获取当前时间
    res = []     # 创建空列表存放下面每次循环运行的实例
    for i in range(10):
        if i == 9:
            i = 2
        t = threading.Thread(target=run, args=(i, i))
        t.start()
        res.append(t)

    for t in res:   # 让每次运行的实例运行完再运行下一次的
        t.join()

    # 运行完后的时间减去运行前的时间得函数运行的时间
    print(f"run()函数共运行了{time.time() - start_time}秒")

查看活动的线程个数（整体2s的）（__name__ == '__main__'自身运行也是一个线程）

import threading
import time

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

if __name__ == '__main__':
    start_time = time.time()  # 获取当前时间
    res = []     # 创建空列表存放下面每次循环运行的实例
    for i in range(50):
        t = threading.Thread(target=run, args=(i, ))
        t.start()
        res.append(t)

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

    for t in res:   # 让每次运行的实例运行完再运行下一次的
        t.join()

    # 运行完后的时间减去运行前的时间得函数运行的时间
    print(f"run()函数共运行了{time.time() - start_time}秒")

查看当前的线程。线程并非按照顺序运行

print(threading.current_thread())

将线程设置为守护线程（让文件运行完了直接退出，不等待）

t.setDaemon(True)