python多线程编程

最新推荐文章于 2023-01-23 22:56:25 发布

小白_橙子

最新推荐文章于 2023-01-23 22:56:25 发布

阅读量173

点赞数

CC 4.0 BY-SA版权

分类专栏： python 文章标签： python多线程编程

本文链接：https://blog.youkuaiyun.com/weixin_43958804/article/details/84919937

python 专栏收录该内容

52 篇文章

订阅专栏

本文深入探讨了多线程编程的基本概念，包括线程与进程的区别，如何使用Python进行多线程编程，以及线程安全问题的产生与解决方法。通过实例讲解了互斥锁的使用，死锁的避免，以及线程同步机制。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

多线程编程

概念

线程:线程包含在进程中,是一个调度单位

进程与线程区别:

进程的创建: 会复制一份父进程的内存空间,具备独立的地址空间,修改全局变量不会有影响,进程之间沟通困难

线程的创建:线程之间共用一个内存空间,修改全局会有影响,会存在线程安全问题,可以添加互斥锁,线程不能够独立执行，必须依存在进程中

代码:

# 导入线程包
import threading
def job(v):
    print(f'{v}  今天要上课{threading.current_thread().name}')
for v in range(10):
    # 创建一个线程
    t = threading.Thread(target=job, args=(v,))
    # 开启线程
    t.start()

线程继承类:

import threading
class Thread1(threading.Thread):
    def __init__(self, name):
        super(Thread1, self).__init__()
        self.name = name
    # 固定的方法
    def run(self):
        print("今天天气好冷", self.name)
# 创建一个线程
t = Thread1("libai")
# 开启线程
t.start()

修改全局变量

import threading
num = 0
def write():
    global num
    num += 1
    print("write", num)
def read():
    global num
    num += 1
    print("read", num)
th = threading.Thread(target=write)
th.start()
th2 = threading.Thread(target=read)
th2.start()
# 结果输出 1 , 2

线程安全问题

产生原因: 时间片轮转时,还没有执行完就已经轮转出去,等到再次轮转回来继续执行,数据已经发生更新

         由于多任务调度的随机性，可能出现一个任务在操作，而另外一个任务也在操作，导致每个任务最终访问的效果出现混乱

import threading
num = 0
def add1():
    global num
    for v in range(1000000):
        num += 1
    print("add1", num)
def add2():
    global num
    for v in range(1000000):
        num += 1
    print("add2", num)
t1 = threading.Thread(target=add1)
t1.start()
t2 = threading.Thread(target=add2)
t2.start()
# 结果  add1 1309780
#	   add2 1690800

线程安全问题的解决:

添加互斥锁:当一个任务获取到以锁定状态的锁时，任务将被放入等待队列，直到这把锁被释放时被唤醒

import threading
num = 0
def add1():
    global num
    # 上锁
    lock.acquire()
    for v in range(1000000):
        num += 1
    # 解锁
    lock.release()
    print("add1", num)
def add2():
    global num
    # 上锁
    lock.acquire()
    for v in range(1000000):
        num += 1
    # 解锁
    lock.release()
    print("add2", num)
# 创建一个互斥锁
lock = threading.Lock()
t1 = threading.Thread(target=add1)
t1.start()
t2 = threading.Thread(target=add2)
t2.start()
# 结果  add1 1000000
#	   add2 2000000

lock.acquire() : 加互斥锁

lock.release() : 解锁

死锁问题

在线程间共享多个资源的时候，如果两个线程分别占有一部分资源并且同时等待对方的资源，就会造成死锁。

尽管死锁很少发生，但一旦发生就会造成应用的停止响应。

#coding=utf-8
import threading
import time

class MyThread1(threading.Thread):
    def run(self):
        if mutexA.acquire():
            print(self.name+'----do1---up----')
            time.sleep(1)

            if mutexB.acquire():
                print(self.name+'----do1---down----')
                mutexB.release()
            mutexA.release()
class MyThread2(threading.Thread):
    def run(self):
        if mutexB.acquire():
            print(self.name+'----do2---up----')
            time.sleep(1)
            # 解决方法: 添加超时时间 blocking=True,timeout=2
            if mutexA.acquire(blocking=True,timeout=2):
                print(self.name+'----do2---down----')
                mutexA.release()
            mutexB.release()
mutexA = threading.Lock()
mutexB = threading.Lock()
if __name__ == '__main__':
    t1 = MyThread1()
    t2 = MyThread2()
    t1.start()
    t2.start()

解决: 添加超时时间

线程同步

import threading
import time
def a():
    while True:
        # 上第一把锁
        if lock1.acquire():
            print("1")
            time.sleep(1)
            # 解第二把锁
            lock2.release()
def b():
    while True:
        if lock2.acquire():
            print("2")
            time.sleep(1)
            lock3.release()
def c():
    while True:
        if lock3.acquire():
            print("3")
            time.sleep(1)
            lock1.release()
# 准备3把锁
lock1 = threading.Lock()
lock2 = threading.Lock()
lock2.acquire()
lock3 = threading.Lock()
lock3.acquire()
t1 = threading.Thread(target=a)
t2 = threading.Thread(target=b)
t3 = threading.Thread(target=c)
t1.start()
t2.start()
t3.start()

死锁

在线程间共享多个资源的时候，如果两个线程分别占有一部分资源并且同时等待对方的资源，就会造成死锁。

尽管死锁很少发生，但一旦发生就会造成应用的停止响应。下面看一个死锁的例子

#coding=utf-8
import threading
import time

class MyThread1(threading.Thread):
    def run(self):
        if mutexA.acquire():
            print(self.name+'----do1---up----')
            time.sleep(1)

            if mutexB.acquire():
                print(self.name+'----do1---down----')
                mutexB.release()
            mutexA.release()

class MyThread2(threading.Thread):
    def run(self):
        if mutexB.acquire():
            print(self.name+'----do2---up----')
            time.sleep(1)
            if mutexA.acquire():
                print(self.name+'----do2---down----')
                mutexA.release()
            mutexB.release()

mutexA = threading.Lock()
mutexB = threading.Lock()

if __name__ == '__main__':
    t1 = MyThread1()
    t2 = MyThread2()
    t1.start()
    t2.start()