Python的threading库的大致使用（细致解释，适合小白）

Pyhon的多线程常使用threading库。

先介绍并解释常用函数。

一:

1.Thread类

thread = threading.Thread(target=my_function)
#用来向python解释器说明那些是要用到多线程的对象。

示例：

import threading

# 自定义一个名为my_function的函数
def my_function():
    print("线程执行")

# 创建线程对象，指定要执行的函数
thread = threading.Thread(target=my_function)

2.start()方法

示例：

# start()的作用在于，告诉python解释器，这个是你的多线程对象
# 或者说，告诉python解释器，你要让它跑起来，运行起来
thread.start()

那么此时，1+2，我们就得到了一个能跑的threading类多线程脚本了。

import threading

def my_function():
    print("线程执行")

thread = threading.Thread(target=my_function)
thread.start()

二：

1.Lock类

# 创建一个锁的对象，也就是说，你要把谁锁住
# 锁的意思与作用是：用于在多线程中防止数据竞争，也就是说，只有在达到你设置的条件时候，才会解锁，也就是执行。
lock = threading.Lock()

示例：

# 创建锁对象
lock = threading.Lock()

2.acquire()

acquire（获取锁）

示例：

# shared_variable 起到了被共享资源的作用，因为后面要被多个线程执行，也就是达到了共享资源
# 而shared_variable本身不是任何函数或有任何作用，只是一个变量而已
# 单纯的声明shared_variable = 0 仅此而已
shared_variable = 0

# 创造个上锁模块
def worker():

    # global是声明全局变量
    global shared_variable

    # 在临界区之前调用 acquire 获取锁，也就是上锁
    lock.acquire()

3.release()

release（释放锁）

示例：

 try:
        # ↓ 此处就是要求，或者说你给的命令：循环执行一百万次的shared_variable += 1
        for _ in range(50):
            # ↓ 这里实际上和上面演示的代码是同一个脚本
            # 不断加1
            shared_variable += 1
    finally:
        # 在离开临界区（达成解锁条件，也就是被for _ in range(1000000)，循环执行一百万次）之后调用 release 释放锁（解锁，也就是执行下一个任务或者完成执行）
        lock.release()

4.join()方法

thread.join()

示例：

# 创建两个线程
thread1 = threading.Thread(target=worker)
thread2 = threading.Thread(target=worker)

# 等待两个线程执行完毕
thread1.join()
thread2.join()

# 此处不完整，仅仅是截取一部分作为直观解释

那么现在，我们将一，二的知识点全部相加，就得到了一个完整的脚本

import threading

shared_variable = 0
lock = threading.Lock()

def worker():
    global shared_variable
    with lock:
        for _ in range(50):
            shared_variable += 1

# 创建两个线程
thread1 = threading.Thread(target=worker)
thread2 = threading.Thread(target=worker)

# 启动线程
thread1.start()
thread2.start()

# 等待两个线程执行完毕
thread1.join()
thread2.join()

print("共享变量的值:", shared_variable)

 三:

以下仅进行简洁，以便后续进行更直观的解释

1.event类

#用于线程间事件通知的类。通过 threading.Event() 创建一个新的事件对象。
event = threading.Event()

2.event.wait()

# 用于等待事件的发生。如果事件已经被设置（set），那么 wait() 方法会立即返回；否则，它将一直阻塞，直到事件被设置。
# 换句话说就是，它是用来检查是否被执行或者说是否发生
event.wait()

3.event,set()

# set() 方法用于设置事件，即将事件的状态设置为"已触发"。一旦事件被设置，所有等待该事件的线程将不再阻塞
event.set()

那么现在，我们进行所学结合，就可以得到一个脚本

import threading
import time

def wait_for_event(event):
    print("等待事件触发")
    
    # 等待事件被设置
    event.wait()    #进行一次阻塞，也就是停止运行
    
    print("事件已触发")

def set_event(event):
    time.sleep(5)    #等待五秒
    print("触发事件")
    
    # 设置事件，通知等待的线程
    event.set()    #设置事件，或者说设置触发点

# 创建对象
event = threading.Event()

# 创建等待事件的线程和触发事件的线程
thread1 = threading.Thread(target=wait_for_event, args=(event,))
thread2 = threading.Thread(target=set_event, args=(event,))

# 启动两个线程
thread1.start()
thread2.start()

# 等待两个线程执行完毕
thread1.join()
thread2.join()

小结：那么现在，恭喜你伙计，你已经大致学会了python的多线程功能。

值得提醒的是，这三个类，也就是lock,event,thread，这三个类，是可以混合使用的，以此来达到你的目的。