目录
一、多任务的概念
二、threading的基本使用
三、多线程共享全局变量
四、同步概念、互斥锁解决资源竞争的问题
五、死锁
一、多任务的概念
简单地说，就是操作系统可以同时执行多个任务
在代码里面，就是一个程序有多个地方同时执行
打个比方，你一边写代码，一边在听歌，一边用着这浏览器上网，这就是多任务
python中的多线程
- python的threading模块是对thread做了一些包装的，可以更加方便的被使用
二、threading的基本使用
代码实现
import threading
import time
def sing():
for i in range(3):
print("张三唱歌停不下来")
time.sleep(1)
def dance():
for i in range(3):
print("张三跳舞停不下来")
time.sleep(1)
def main():
pass
t1 = threading.Thread(target=sing)
t2 = threading.Thread(target=dance)
t1.start() # 启动线程，即让线程开始执行
t2.start()
if __name__ == '__main__':
main()
thread的基本使用.gif
说明
- 当调用start()时，才会真正的创建线程，并且开始执行
- 主线程会等待所有的子线程结束后才结束
三、多线程共享全局变量
- 函数里面修改全局变量
import threading
import time
g_num = 100
def test1():
global g_num
g_num += 1
print("----test1 g_num = %d-----" % g_num)
def test2():
print("----test2 g_num = %d-----" % g_num)
def main():
t1 = threading.Thread(target=test1)
t2 = threading.Thread(target=test2)
t1.start()
time.sleep(1)
t2.start()
time.sleep(1)
if __name__ == '__main__':
main()
打印结果为：
函数里面修改全局变量.png
- 多线程里面传递参数
import threading
import time
g_nums = [11, 22]
def test1(temp):
temp.append(33)
print("----test1 temp = %s-----" % str(temp))
def test2(temp):
print("----test2 temp = %s-----" % str(temp))
def main():
# target 指定将来这个线程去哪个函数执行代码
# args 指定将来调研函数的时候 传递什么数据过去
t1 = threading.Thread(target=test1, args=(g_nums,))
t2 = threading.Thread(target=test2, args=(g_nums,))
t1.start()
time.sleep(1)
t2.start()
time.sleep(1)
if __name__ == '__main__':
main()
多线程里面传递参数.png
小结
- 子线程和子线程之间共享全局变量
四、同步概念、互斥锁解决资源竞争的问题
import threading
import time
g_num = 0
def test1(num):
global g_num
for i in range(num):
g_num += 1
print("----test1 g_num = %d-----" % g_num)
def test2(num):
global g_num
for i in range(num):
g_num += 1
print("----test2 g_num = %d-----" % g_num)
def main():
while True:
count = int(input("请输入一个值:"))
t1 = threading.Thread(target=test1, args=(count,))
t2 = threading.Thread(target=test2, args=(count,))
t1.start()
t2.start()
# 等待上面的2个线程执行完毕
time.sleep(2)
print("----最终 g_num = %d-----" % g_num)
if __name__ == '__main__':
main()
资源竞争的问题.png
由打印结果得知：当输入的值越大，计算出来的结果误差就越大。
执行过程.png
分析执行过程
先执行线程1，当执行完第1，2步之后，g_num的值为1 还没有将结果存储g_num中。操作系统就开始执行线程2里面的函数，当执行完第1，2步 之后，g_num的值为1 还没有将结果存储g_num中，又去执行线程1里面的第三步了，此时线程1的g_num = 1, 接着又去执行线程2里面的第三步，此时线程2的g_num 也为1。按理来说，线程1执行完毕之后，再执行线程2时，此时g_num最终值为2
对于上面计算错误的问题，可以通过线程同步来进行解决，接着往下看
解决资源竞争的问题思路，如下:
- 系统调用t1，然后获取到g_num的值为0，此时上一把锁，即不允许其他线程操作g_num
- t1对g_num的值进行+1
- t1解锁，此时g_num的值为1，其他的线程就可以使用g_num了，而且是g_num的值不是0而是1
- 同理其他线程在对g_num进行修改时，都要先上锁，处理完后再解锁，在上锁的整个过程中不允许其他线程访问，就保证了数据的正确性
互斥锁解决资源竞争的问题
import threading
import time
g_num = 0
# 创建锁
mutex = threading.Lock()
def test1(num):
global g_num
# 上锁，如果之前没有被上锁，那么此时上锁成功 反之上锁之前已经被锁上了 则会堵塞，直到这个锁被解开为止
mutex.acquire()
for i in range(num):
g_num += 1
# 解锁
mutex.release()
print("----test1 g_num = %d-----" % g_num)
def test2(num):
global g_num
mutex.acquire()
for i in range(num):
g_num += 1
mutex.release()
print("----test2 g_num = %d-----" % g_num)
def main():
while True:
count = int(input("请输入一个值:"))
t1 = threading.Thread(target=test1, args=(count,))
t2 = threading.Thread(target=test2, args=(count,))
t1.start()
t2.start()
# 等待上面的2个线程执行完毕
time.sleep(2)
print("----最终 g_num = %d-----" % g_num)
if __name__ == '__main__':
main()
互斥锁解决资源竞争的问题.png
五、死锁
在线程间共享多个资源的时候，如果两个线程分别占有一部分资源并且同时等待对方的资源，就会造成死锁。
import threading
import time
mutexA = threading.Lock()
mutexB = threading.Lock()
class Thread1(threading.Thread):
def run(self):
# 对mutexA上锁
mutexA.acquire()
# mutexA上锁后，延时1秒，等待另外那个线程 把mutexB上锁
print("----Thread1--mutexA-------")
time.sleep(1)
# 此时会堵塞，因为这个mutexB已经被另外的线程抢先上锁了
mutexB.acquire()
print("----Thread1--mutexB-------")
mutexB.release()
# 对mutexA解锁
mutexA.release()
class Thread2(threading.Thread):
def run(self):
mutexB.acquire()
print("----Thread2--mutexB-------")
time.sleep(1)
mutexA.acquire()
print("----Thread2--mutexB-------")
mutexA.release()
mutexB.release()
def main():
t1 = Thread1()
t2 = Thread2()
t1.start()
t2.start()
if __name__ == '__main__':
main()
死锁状态.png
