Python高级学习第三课 2022-01-08

多线程

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

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

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

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

以类的方式创建两个多线程：

import threading
import time


class MyThread(threading.Thread):
    def __init__(self,n):
        super(MyThread, self).__init__()
        self.n = n

    def run(self):
        print("以类的方式创建多线程",self.n)
        time.sleep(3)
r1 = MyThread(11)#创建多线程1
r2 = MyThread(22)#创建多线程2
r1.start()#启动多线程1
r2.start()#启动多线程2

多线程的特性：

计算程序运行时间：

print(time.time())#从1970年到现在经过的秒数
start_time = time.time()#开始运行时的秒数
print(time.time() - start_time)#程序运行的秒数

t1.join()：使线程运行完成后等待一定时间在运行另一个线程

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

查看活动线程的个数：

print(threading.active_count())

查看当前线程：

print(threading.current_thread())

线程锁：一个线程在操作时锁住该数，使另一个线程无法操作。

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)

一个例子：

# 在一个线程中，每秒循环输出当前的年月日时分秒；
# 于此同时，在另一个线程中，实现张三的姓名每2秒打印输出4次结束。

import threading
import time
#创建一个类，并继承threading.Thread
class MyThread1(threading.Thread):
    def run(self):#定义一个方法
        for i in range(8):#循环八次
            # 获取时间并打印
            print(time.strftime("%Y-%m-%d %H:%M:%S",time.localtime()))
            i = 0
            i += 1
            time.sleep(1)#使线程每隔一秒打印一次
#创建一个类，并继承threading.Thread
class MyThread2(threading.Thread):
    def __init__(self, name):#初始化方法，调用类时会被自动调用
        super(MyThread2, self).__init__()# 实例化对象属性
        self.name = name#把形参name赋值给属性
    def run(self):# 重写Thread类中的run方法
        for i in range(4):#循环四次
            print(self.name)#打印输入的参数
            time.sleep(2)#使线程每隔两秒打印一次

if __name__ == '__main__':
    t1 = MyThread1()# 创建线程对象t1
    t2 = MyThread2("张三")# 创建线程对象t2，传入参数张三
    t1.start()  # 用start方法启动线程
    t2.start()# 用start方法启动线程

递归锁

递归锁也称为可重入互斥锁，是互斥锁的一种，同一线程对其多次加锁不会产生死锁。