当前位置：首页 > article >正文

【Python】线程

article 2025/1/11 20:56:29

1. 线程的创建与销毁

2. 线程共享全局变量

3. 互斥锁

4. 进程和线程的对比

1. 线程的创建与销毁

线程是进程的一个分支，进程默认有一个线程，但也可以有多个线程

线程是CPU调度的基本单位

线程是依附在进程里面的，由进程创建，没有进程就没有线程

线程的模块：threading

线程的运行是无序的

主线程退出并不影响子线程的运行

线程的参数与进程一样：Thread(group, target, name, args, kwargs)

保护机制：join()

import threading
import os
import time

def ChildThread1(cnt):
    for i in range(cnt):
        print(f'{i} 这是第 1 个子线程, pid=', os.getpid())
        time.sleep(0.5)

def ChildThread2(cnt):
    for i in range(cnt):
        print(f'{i} 这是第 2 个子线程')
        time.sleep(0.5)

if __name__ == '__main__':
    # 创建子线程
    childThread1 = threading.Thread(target=ChildThread1, args=(6,))  # 用逗号区分元组和普通括号
    childThread2 = threading.Thread(target=ChildThread2, kwargs={'cnt': 6})

    # 运行子线程
    childThread1.start()
    childThread2.start()

    # 主线程代码
    for i in range(3):
        print('这是主线程, pid=', os.getpid())
        time.sleep(0.5)
    print('主进程循环结束')
    childThread1.join()
    for i in range(3):
        print('主进程等待线程完毕')
        time.sleep(1)

2. 线程共享全局变量

import threading

# 创建全局变量
g_cnt = 0

def Sum1():
    global g_cnt
    for i in range(2000000):
        g_cnt += 1
    print(f'Sum1: g_cnt = {g_cnt}')

def Sum2():
    global g_cnt
    for i in range(2000000):
        g_cnt += 1
    print(f'Sum2: g_cnt = {g_cnt}')

if __name__ == '__main__':
    childThread1 = threading.Thread(target=Sum1)
    childThread2 = threading.Thread(target=Sum2)

    childThread1.start()
    childThread2.start()

由运行结果可得，线程之间可共享全局变量，且每次运行的结果都不一样

由于全局变量在两个线程中来回切换，故两个线程得到的结果都一定大于等于循环数，小于等于总循环数

限制全局变量的切换：1. 线程等待 join 2. 互斥锁 lock

3. 互斥锁

当有线程开始执行任务前，先将全局变量锁定，不让其他的线程使用这个变量，当它执行完成后，再开锁，允许其他线程使用

互斥锁的锁定和释放要搭配使用，上锁之后必须要释放

每次只有一个线程可以获得锁，如果此时另一个线程试图获得锁，就必须进程阻塞等待那个正在被使用的锁被释放

创建锁：lock = threadding.Lock()

锁定：lock.acquire()

释放：lock.release()

import threading

# 创建全局变量
g_cnt = 0

# 创建锁
lock = threading.Lock()

def Sum1():
    lock.acquire()
    global g_cnt
    for i in range(2000000):
        g_cnt += 1
    print(f'Sum1: g_cnt = {g_cnt}')
    lock.release()

def Sum2():
    lock.acquire()
    global g_cnt
    for i in range(2000000):
        g_cnt += 1
    print(f'Sum2: g_cnt = {g_cnt}')
    lock.release()

if __name__ == '__main__':
    childThread1 = threading.Thread(target=Sum1)
    childThread2 = threading.Thread(target=Sum2)

    childThread1.start()
    childThread2.start()