浅谈python多线程和多线程变量共享问题介绍

1、demo

第一个代码是多线程的简单使用，编写了线程如何执行函数和类。

import threading
import time
class ClassName(threading.Thread):
"""创建类，通过多线程执行"""
def run(self):
for i in range(5):
print(i)
time.sleep(1)

def sing():
for i in range(1,11):
print("唱歌第 %d 遍" % i)
time.sleep(1)

def dance():
for i in range(1,16):
print("跳舞第 %d 遍" % i)
time.sleep(1)

def main():
t1 = threading.Thread(target = sing)
t2 = threading.Thread(target = dance)
t = ClassName()

# 启动线程
t1.start()
t2.start()
t.start()

while True:
length = len(threading.enumerate())
print("正在运行的线程有 %s" %threading.enumerate())

if length <= 1:
break
time.sleep(1)

if __name__ == '__main__':
main()

执行结果可以看到函数 sing、dance和类在同时执行，执行效果太长就不方截图了

2、多线程共享变量

通过定义全局变量，然后再test1函数类部进行更改全局变量，test2打印全局变量。

import threading
import time

#定义全局变量
g_num = 0

def test1():
"""函数test1对全局变量进行更改"""
global g_num
for i in range(1,10):
g_num += 1

print("--- test1 线程 g_num = %d--- " % g_num)

def test2():
"""函数test2 打印全局变量"""
print("--- test2 线程 g_num = %d--- " % g_num)

def main():
t1 = threading.Thread(target=test1)
t2 = threading.Thread(target=test2)

# 启动线程
t1.start()
# 增加睡眠是为了保证优先执行函数test1
time.sleep(1)
t2.start()

print("--- 主线程 g_num = %d--- " % g_num)

if __name__ == '__main__':
main()

执行结果可以看出,在主线程和创建的两个线程中读取的是一样的值，既可以表明在多线程中变量共享

3、资源竞争

在多线程两个函数中同时更改一个变量时，由于cpu的计算能力，当修改参数的代码块无法一次性执行完成时，就会产生资源竞争

import threading
import time

# 定义全局变量
g_num = 0

def test1(num):
"""函数test1对全局变量进行更改"""
global g_num
for i in range(num):
g_num += 1

print("test1 线程 g_num = %d---" % g_num)

def test2(num):
"""函数test2对全局变量进行更改"""
global g_num
for i in range(num):
g_num += 1

print("tes2 线程 g_num = %d---" % g_num)

def main():
t1 = threading.Thread(target=test1, args=(1000000, ))
t2 = threading.Thread(target=test2, args=(1000000, ))

t1.start()
t2.start()

time.sleep(1)
print("主线程 g_num = %d---" % g_num)

if __name__ == '__main__':
main()

可以先试试传递参数为100时，可以看到g_num = 200 这是因为函数代码可以一次性执行完成，当参数为1000000时代码无法一次性执行完成，g_num！= 2000000

4、互斥锁

互斥锁可以解决资源竞争的问题，原理很简单，通过对代码块上锁，保证该代码执行完成前，其它代码无法进行修改。执行完成后解锁，其它代码就可以执行了。

import threading
import time

# 创建变量
g_num = 0
# 创建锁默认为开锁状态
mutex = threading.Lock()

def test1(num):
global g_num
for i in range(num):
# 上锁
mutex.acquire()
g_num += 1
# 解锁
mutex.release()
print("--- test1 线程 g_num = %d---" % g_num)

def test2(num):
global g_num
for i in range(num):
# 上锁
mutex.acquire()
g_num += 1
# 解锁
mutex.release()

print("--- test2 线程 g_num = %d---" % g_num)

def main():
t1 = threading.Thread(target=test1, args=(1000000, ))
t2 = threading.Thread(target=test2, args=(1000000, ))

t1.start()
t2.start()

time.sleep(1)
print("--- 主线程 g_num = %d---" % g_num)

if __name__ == '__main__':
main()

可以看到加了锁之后，代码执行不会出现资源竞争，结果也是正常的。互斥锁，上锁的代码越少越好。

5、死锁

当出现多个锁时，就可能会产生死锁这个情况。当关闭一个锁时，这个锁已经为关闭状态的话，程序就会阻塞。就如同下面这个代码中。函数test1关闭mutexB锁时，函数test2提前将其关闭了，未进行解锁，程序就会一直阻塞。

import threading
import time

# 创建两个锁A, B
mutexA = threading.Lock()
mutexB = threading.Lock()

def test1():
# 对muctexA上锁
mutexA.acquire()

# mutexA上锁后，延时1秒，等待mutexB上锁
print("test1 ---do1---up---")
time.sleep(1)
# 此时会堵塞，因为mutexB已经上锁
mutexB.acquire()
print("test1 ---do1---down---")
mutexB.release()

# 对mutexA解锁
mutexA.release()

def test2():
# 对muctexB上锁
mutexB.acquire()

# mutexB上锁后，延时1秒，等待mutexA上锁
print("test2 ---do1---up---")
time.sleep(1)
# 此时会堵塞，因为mutexB已经上锁
mutexA.acquire()
print("test2 ---do1---down---")
mutexA.release()

# 对mutexA解锁
mutexB.release()

def main():
t1 = threading.Thread(target=test1)
t2 = threading.Thread(target=test2)

t1.start()
t2.start()

if __name__ == '__main__':
main()

代码执行效果可以看到程序会一直阻塞
解决方法
1、在程序编写时，就需要注意避免死锁
2、可以参考银行家算法

到此这篇关于浅谈python多线程和多线程变量共享问题介绍的文章就介绍到这了,更多相关python 多线程变量共享内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

• python多线程共享变量的使用和效率方法
• Python 多线程共享变量的实现示例