python面向对象学习3

python面向对象学习3

文章目录

一、多线程二、多线程的特性

1.查看运行时间2.查看活动线程 三、线程锁四、递归锁

一、多线程

什么是多线程： 1．线程是程序执行的最小单位，而进程是 *** 作系统分配资源的最小单位;
2.一个进程由一个或多个线程组成，线程是一个进程中代码的不同执行路线。
3，进程之间相互独立，但同一进程下的各个线程之间共享程序的内存空间(包括代码段，数据集，堆等)及一些进程级的资源(如打开文伊拉培:号等)，某进程内的线程在其他进程不可见;
4.调度和切换:线程上下文切换比进程上下文切换要快得多

函数建立多线程:

import threading
import time
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):
    def __init__(self, n):
        super(MyThread, self).__init__()
        self.n = n

    def run(self):
        print('以类的方式创建多线程',self.n)
        time.sleep(3)

r1 = MyThread(11)
r2 = MyThread(22)
r1.start()
r2.start()

二、多线程的特性 1.查看运行时间

注意：time.time()，是1970年到现在共走了多少秒

代码如下：

import time

def run(x):
    print(f"线程{x}")
    time.sleep(2)
    
start_time = time.time() #设置一个运行开始的时间
run(1)
run(2)
print(f"run()函数共运行了{time.time() - start_time}秒")

等待用.join函数

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)

    for t in res:
        t.join()




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

2.查看活动线程

threading.active_count()

三、线程锁

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()

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('程序运行结束')