《python》—— threading库（线程和多线程）

threading简介

threading 是 Python 标准库中用于实现多线程编程的模块。多线程编程允许程序同时执行多个任务，提高程序的并发性能，尤其适用于 I/O 密集型任务，例如网络请求、文件读写等。、

threading基本概念

• 线程（Thread）：是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。
• 多线程（Multithreading）：指的是在一个程序中同时运行多个线程，每个线程可以独立执行不同的任务。

常用类和方法

• Thread 类
  • Thread 类是 threading 模块中最核心的类，用于创建和管理线程。
    • 创建线程的方式：

      • 方式一：直接实例化 Thread 类

        import threading
        
        # 定义一个函数作为线程要执行的任务
        def print_numbers():
            for i in range(5):
                print(f"Number: {i}")
        
        # 创建线程对象
        thread = threading.Thread(target=print_numbers)
        
        # 启动线程
        thread.start()
        
        # 等待线程执行完毕
        thread.join()
        
        print("Main thread finished.")
        

      • 结果：
        

      • 方式二：继承 Thread 类

        import threading
        
        # 自定义线程类，继承自 threading.Thread
        class MyThread(threading.Thread):
            def run(self):
                for i in range(5):
                    print(f"Number: {i}")
        
        # 创建线程对象
        thread = MyThread()
        
        # 启动线程
        thread.start()
        
        # 等待线程执行完毕
        thread.join()
        
        print("Main thread finished.")
        

      • 结果：
        

    • 其他常用方法和属性

      • getName() 和 setName()：用于获取和设置线程的名称。

        import threading
        
        def print_hello():
            print(f"Hello from {threading.current_thread().getName()}")
        
        thread = threading.Thread(target=print_hello)
        thread.setName("MyThread")
        thread.start()
        thread.join()
        

      • is_alive()：用于判断线程是否还在运行。

        import threading
        import time
        
        def long_task():
            time.sleep(2)
        
        thread = threading.Thread(target=long_task)
        thread.start()
        print(f"Thread is alive: {thread.is_alive()}")
        thread.join()
        print(f"Thread is alive: {thread.is_alive()}")
        

        

线程同步

在多线程编程中，多个线程可能会同时访问和修改共享资源，这可能会导致数据不一致的问题。为了解决这个问题，threading 模块提供了一些同步机制。

• Lock 类

  • Lock 是一种最基本的同步原语，用于确保同一时间只有一个线程可以访问共享资源。

    import threading
    
    # 创建一个锁对象
    lock = threading.Lock()
    shared_variable = 0
    
    def increment():
        global shared_variable
        for _ in range(100000):
            # 获取锁
            lock.acquire()
            try:
                shared_variable += 1
            finally:
                # 释放锁
                lock.release()
    
    threads = []
    for _ in range(2):
        thread = threading.Thread(target=increment)
        threads.append(thread)
        thread.start()
    
    for thread in threads:
        thread.join()
    
    print(f"Shared variable: {shared_variable}")
    

    

• RLock 类
  • RLock 是可重入锁，允许同一个线程多次获取锁而不会导致死锁。

    import threading
    
    # 创建一个可重入锁对象
    rlock = threading.RLock()
    
    def recursive_function():
        rlock.acquire()
        try:
            print("Lock acquired")
            recursive_function()
        finally:
            rlock.release()
    
    thread = threading.Thread(target=recursive_function)
    thread.start()
    thread.join()
    

线程池

虽然 threading 模块本身没有直接提供线程池的功能，但可以使用 concurrent.futures 模块中的 ThreadPoolExecutor 来实现线程池。

import concurrent.futures

def square(x):
    return x * x

with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
    results = executor.map(square, [1, 2, 3, 4, 5])

for result in results:
    print(result)

在上述代码中，ThreadPoolExecutor 用于创建一个线程池，max_workers 参数指定了线程池中的最大线程数。executor.map() 方法用于并行执行任务

实例

实例代码展示了 Python 中 threading 模块的基本使用，包括创建线程、启动线程以及向线程函数传递参数等操作。

import threading


def worker():
    print('线程开始执行')
    for i in range(5):
        print(f'线程正在工作：{i}')
    print('线程执行完毕')
thread = threading.Thread(target=worker)
thread.start()
print('***主线程继续执行***')


'''传递参数'''
def worker(name):
    print(f'{name}线程开始执行')
    for i in range(5):
        print(f'{name}正在工作：{i}')
    print(f'{name}线程执行完毕')

thread = threading.Thread(target=worker,args=('线程1',))
thread.start()
print('***主线程继续执行***')

import threading
import time

def run(n):
    print('task', n)
    time.sleep(1)
    print('2s')
    time.sleep(1)
    print('1s')
    time.sleep(1)

def run2(t):
    time.sleep(t)
    print(f'我等了{t}秒')

if __name__ == '__main__':
    t1 = threading.Thread(target=run, args=('t1',))
    t2 = threading.Thread(target=run, args=('t2',))
    # 启动 t1 和 t2 线程
    t1.start()
    t2.start()

    # 修正参数，传递整数秒数
    t3 = threading.Thread(target=run2, args=(5,))
    t4 = threading.Thread(target=run2, args=(8,))
    # 启动 t3 线程
    t3.start()
    # 启动 t4 线程
    t4.start()

    # 主线程等待 10 秒
    time.sleep(10)
    print('开始倒计时')

结果：