1.线程的并发实现以及线程数的显示
import time
import threading #线程(并发)
def sing():
for i in range(5):
print("sing--%d" % i)
time.sleep(1)
def dance():
for i in range(5):
print("dance---%d" % i)
time.sleep(1)
def main():#线程一起执行-假的多任务(时间片轮转)
t1 = threading.Thread(target = sing)
t2 = threading.Thread(target = dance)
t1.start()
t2.start()
#查看线程数
while True:
print(threading.enumerate())
if len(threading.enumerate())<=1:
break
time.sleep(1)
if __name__ == "__main__":
main()
2.类线程的并发实现
import threading
import time
class MyThread(threading.Thread):
def run(self):
self.sing()
self.dance()
def sing(self):
for i in range(5):
print("sing--%d" % i)
time.sleep(1)
def dance(self):
for i in range(5):
print("dance---%d" % i)
time.sleep(1)
if __name__ == '__main__':
t1 = MyThread()
t1.start()
t2 = MyThread()
t2.start()
3.多个线程之间共享全局变量实现
#多个线程之间共享全局变量
import threading
import time
#定义一个全局变量
num = 100
data = [11, 22] #传递的参数必须是一个可以迭代的容器
def tes1(temp):
global num
num += 1
print("------test1 num = %d----" % num)
print("传递数据测试 %s" % str(temp))
def tes2():
global num
print("------test2 num = %d----" % num)
def main():
#target指定将来去哪个函数执行代码
#args指定将来调用函数的时候传递什么数据过去--传递的参数必须是一个可以迭代的容器
t1 = threading.Thread(target = tes1, args=(data,))
t2 = threading.Thread(target = tes2)
t1.start()
time.sleep(1)
t2.start()
time.sleep(1)
print("----main num = %d" % num)
if __name__ == '__main__':
main()
4.多线程执行当同时进行写操作时出现的错误, 并通过互斥锁的方法进行解决
- 出现问题
#共享全局变量的问题--资源竞争
import threading
import time
#定义一个全局变量
num = 100
data = 1000000 #操作的数越大,共享资源产生的问题就越明显--计算的结果还没有进行赋值就不给分配cpu了
def tes1(temp):
global num
for i in range(temp):
num += 1
print("------test1 num = %d----" % num)
def tes2(temp):
global num
for i in range(temp):
num += 1
print("------test2 num = %d----" % num)
def main():
#target指定将来去哪个函数执行代码
#args指定将来调用函数的时候传递什么数据过去--传递的参数必须是一个可以迭代的容器
t1 = threading.Thread(target = tes1, args=(data,))
t2 = threading.Thread(target = tes2, args=(data,))
t1.start()
t2.start()
#进行延时--保证子线程执行完之前主线程一直存在
time.sleep(5)
print("----main num = %d" % num)
if __name__ == '__main__':
main()
并没有实现加和为2000100
- 利用互斥锁解决
#多线程共享资源的问题解决--原子性(同步-互斥锁)--成为了串行操作
import threading
import time
#定义一个全局变量
num = 100
data = 1000000 #操作的数越大,共享资源产生的问题就越明显--计算的结果还没有进行赋值就不给分配cpu了
"""串行"""
def tes1(temp):
global num
#上锁--谁先抢到锁就先执行谁
mutex.acquire()
for i in range(temp):
num += 1
#解锁
mutex.release()
print("------test1 num = %d----" % num)
def tes2(temp):
global num
# 上锁谁先抢到锁就先执行谁
mutex.acquire()
for i in range(temp):
num += 1
# 解锁
mutex.release()
print("------test2 num = %d----" % num)
"""并行"""
def tes1(temp):
global num
for i in range(temp):
mutex.acquire()
num += 1
mutex.release()
print("------test1 num = %d----" % num)
def tes2(temp):
global num
for i in range(temp):
mutex.acquire()
num += 1
mutex.release()
print("------test2 num = %d----" % num)
#创建互斥锁,默认没有上锁
mutex = threading.Lock()
def main():
#target指定将来去哪个函数执行代码
#args指定将来调用函数的时候传递什么数据过去--传递的参数必须是一个可以迭代的容器
t1 = threading.Thread(target = tes1, args=(data,))
t2 = threading.Thread(target = tes2, args=(data,))
t1.start()
t2.start()
#进行延时--保证子线程执行完之前主线程一直存在
time.sleep(2)
print("----main num = %d" % num)
if __name__ == '__main__':
main()