多线程python实例

多线程

1.基本多线程

import threading
import time

def print_numbers():
    for i in range(5):
        time.sleep(1)
        print(f"Thread 1: {i}")

def print_letters():
    for letter in 'ABCDE'://字符串的遍历
        time.sleep(1)
        print(f"Thread 2: {letter}")

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

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

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

print("Main thread done.")

解释：print_numbers 和 print_letters 是两个线程执行的函数。threading.Thread 类被用于创建线程对象，start 方法用于启动线程，join 方法用于等待线程执行完成

2.多线程需要解决的问题

1.数据竞争

import threading
import time

# 共享的变量
shared_variable = 0

# 创建锁
lock = threading.Lock()

# 线程执行的函数
def update_shared_variable():
    global shared_variable

    for _ in range(100000):
        # 获取锁
        lock.acquire()

        try:
            # 对共享变量进行操作
            shared_variable += 1
        finally:
            # 释放锁
            lock.release()

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

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

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

print("Shared variable value:", shared_variable)

解释：两个线程都执行 update_shared_variable 函数，该函数通过获取锁 (lock.acquire()) 来确保对 shared_variable 的操作是原子的。通过 lock.release() 来释放锁，确保其他线程可以获取锁并访问共享资源。

操作是原子的：在多线程编程中，原子操作是一种不可分割的操作，即要么操作完全执行，要么不执行，不存在中间状态

上下文管理器：代码块简化,自动完成锁的获取和释放

import threading
import time

shared_variable = 0
lock = threading.Lock()

def update_shared_variable():
    global shared_variable

    for _ in range(100000):
        # 使用上下文管理器简化锁的管理
        with lock:
            shared_variable += 1

2.死锁

死锁是多线程或多进程编程中一种常见的问题，它发生在两个或多个线程或进程相互等待对方释放资源的情况下

四个条件：1.互斥
		2.占有等待
		3.非抢占条件
		4.循环等待
解决：超时机制，破坏四条件

工厂加工程序

import threading
import time
condtion = threading.Condition()
sheep = ['1件产品','1件产品','1件产品','1件产品','1件产品']
class Producer(threading.Thread):
    def __init__(self, name):
        super().__init__(name=name)
        pass
    def run(self):
        global condtion, sheep
        while True:
            time.sleep(0.1)
            condtion.acquire()
            if len(sheep) < 10:
                print(self.name + "生产了1件产品")
                sheep.append('1件产品')
                condtion.notifyAll()
                pass
            else:
                print("仓库满了，停止生产!")
                condtion.wait()
                pass
            condtion.release()
        pass
    pass
class Customer(threading.Thread):
    def __init__(self, name):
        super().__init__(name=name)
        pass
    def run(self):
        global condtion, sheep
        while True:
            time.sleep(0.1)
            condtion.acquire()
            if len(sheep) > 0:
                meat = sheep.pop()
                print(self.name + "购买了" + meat + "还剩多少" + str(len(sheep)) + "件")
                condtion.notifyAll()
                pass
            else:
                print("买光了，等待")
                condtion.wait()
                pass
            condtion.release()
        pass
    pass
if __name__ == "__main__":
    p1 = Producer("1号生产车间")
    p2 = Producer("2号生产车间")
    p3 = Producer("3号生产车间")
    p4 = Producer("4号生产车间")
    p5 = Producer("5号生产车间")
    p6 = Producer("6号生产车间")
    p1.start()
    p2.start()
    p4.start()
    p5.start()
    p6.start()
    c1 = Customer('小王')
    c2 = Customer('小李')
    c3 = Customer('小贾')
    c4 = Customer('小沈')
    c5 = Customer('小刘')
    c1.start()
    c2.start()
    c3.start()
    c4.start()
    c5.start()