6.0多线程任务-全局变量

#coding:utf-8
import threading
import time

class MyThread(threading.Thread):
	def run(self):  
		for i in range(3):
			time.sleep(1)
			msg = "I'm " + self.name + ' @ ' + str(i)  #name属性中保存的是当前线程的名字
			print(msg)

if __name__ = '__main__':
	t = MyThread()  # 类的方法再多也只有一个线程
	t.start()  # 只调用run方法，所以要在run方法里调用其他方法

线程之间共享全局变量 

#coding:utf-8
import threading
import time

#定义一个全局变量，主线程和子线程之间共享全局变量
g_num = 100

def test1():
	global g_num
	g_num += 1
	print('----in test1 g_num = %d' % g_num)

def test2():
	print('----in test2 g_num = %d' % g_num)

def main():
	t1 = threading.Thead(target = test1)
	t2 = threading.Thead(target = test2)
	t1.start()
	time.sleep(1)

	t2.start()
	time.sleep(1)

	print('----in main Thread g_num = %d' % g_num)

if __name__ == '__main__':
	main()

#coding:utf-8
import threading
import time

def test1(temp):
	temp.append(33)  # 插入一个33
	print('----in test1 temp = %s' % str(temp))

def test2(temp):
	print('----in test2 temp = %s' % str(temp))

g_nums = [11, 22]

def main():
	# target 指定将来这个线程去哪个函数执行代码
	# args 指定将来调用这个函数的时候传递什么数据过去
	t1 = threading.Thead(target=test1, args=(g_nums,))  #元组
	t2 = threading.Thead(target=test2, args=(g_nums,))

	t1.start()
	time.sleep(1)

	t2.start()
	time.sleep(1)

	print('----in main Thread g_num = %s' % str(g_nums))

if __name__ == '__main__':
	main()

全局变量之线程间资源竞争

#coding:utf-8
import threading
import time

# 创建一个全局变量
g_num = 0

def test1(num):
	global g_num
	for i in range(num):
		g_num += 1
	print('----in test1 g_num = %d' % g_num)

def test2(num):
	global g_num
	for i in range(num):
		g_num += 1
	print('----in test2 g_num = %d' % g_num)

def main():
	# target 指定将来这个线程去哪个函数执行代码
	# args 指定将来调用这个函数的时候传递什么数据过去
	t1 = threading.Thead(target=test1, args = (1000000,))  #元组
	t2 = threading.Thead(target=test2, args = (1000000,))  #元组

	t1.start()
	t2.start()

	time.sleep(5)  # 等待上面两个线程执行完毕
	print('----in main Thread g_num = %d' % g_num)

if __name__ == '__main__':
	main()

互斥锁-解决资源竞争问题

方案1，两个线程其中一个上锁，执行完这个线程再执行下一个线程

#coding:utf-8
import threading
import time

# 创建一个全局变量
g_num = 0

def test1(num):
	global g_num
	# 上锁，如果之前没有上锁，那么此时上锁成功
	# 如果上锁之前已经被上锁了，那么此时会堵塞在这里，直到锁被解开
	mutex.acquire()
	for i in range(num):
		g_num += 1

	# 解锁
	mutex.release()
	print('----in test1 g_num = %d' % g_num)

def test2(num):
	global g_num
	for i in range(num):
		g_num += 1
	print('----in test2 g_num = %d' % g_num)

# 创建一个互斥锁，默认没有上锁
mutex = threading.lock()

def main():
	# target 指定将来这个线程去哪个函数执行代码
	# args 指定将来调用这个函数的时候传递什么数据过去
	t1 = threading.Thead(target=test1, args = (1000000,))  #元组
	t2 = threading.Thead(target=test2, args = (1000000,))  #元组

	t1.start()
	t2.start()

	time.sleep(5)  # 等待上面两个线程执行完毕
	print('----in main Thread g_num = %d' % g_num)

if __name__ == '__main__':
	main()

方案2，每次循环计算都上锁，两个线程轮流执行

#coding:utf-8
import threading
import time

# 创建一个全局变量
g_num = 0

def test1(num):
	global g_num
	# 上锁，如果之前没有上锁，那么此时上锁成功
	# 如果上锁之前已经被上锁了，那么此时会堵塞在这里，直到锁被解开
	for i in range(num):
		mutex.acquire()
		g_num += 1
		mutex.release()

	print('----in 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('----in test2 g_num = %d' % g_num)

# 创建一个互斥锁，默认没有上锁
mutex = threading.lock()

def main():
	# target 指定将来这个线程去哪个函数执行代码
	# args 指定将来调用这个函数的时候传递什么数据过去
	t1 = threading.Thead(target=test1, args = (1000000,))  #元组
	t2 = threading.Thead(target=test2, args = (1000000,))  #元组

	t1.start()
	t2.start()

	time.sleep(5)  # 等待上面两个线程执行完毕
	print('----in main Thread g_num = %d' % g_num)

if __name__ == '__main__':
	main()