python 多线程学习-2

python 多线程学习-2

多线程-共享全局变量

import threading
import time

g_num=100
def work1():
	global g_num
	for i in range(1,10):
		g_num+=1
	print("g_num is %d"%g_num)


print("线程创建之前 g_num is %d"%g_num)
w1=threading.Thread(target=work1)
w1.start()
#延时⼀会，保证w1线程中的事情做完
time.sleep(1)
w2=threading.Thread(target=work1)
w2.start()

运行结果

列表当做实参传递到线程中

import threading
import time


def work1(nums):
	nums.append(44)
	print(nums)


g_nums=[11,22,33]

w1=threading.Thread(target=work1,args=(g_nums,))
w1.start()
#延时⼀会，保证w1线程中的事情做完
time.sleep(1)
w2=threading.Thread(target=work1,args=(g_nums,))
w2.start()

在一个进程内的所有线程共享全局变量，很方便在多个线程间共享数据
缺点就是，线程是对全局变量随意遂改可能造成多线程之间对全局变量的混乱（即非线程安全）

多线程开发可能遇到的问题

如果多个线程同时对同一个全局变量操作，会出现资源竞争问题，从而数据结果会不正确

测试1

import threading
import time


g_num=0
def work1(num):
	global g_num
	for x in range(num):
		g_num+=1
	print("work1:"+str(g_num))

def work2(num):
	global g_num
	for x in range(num):
		g_num+=1
	print("work2:"+str(g_num))

w1=threading.Thread(target=work1,args=(100,))
w1.start()

w2=threading.Thread(target=work2,args=(100,))
w2.start()

while len(threading.enumerate())!=1:
	time.sleep(1)
	
print("2个线程对同⼀个全局变量操作之后的最终结果是:%s" % g_num)

运行结果

测试1

import threading
import time


g_num=0
def work1(num):
	global g_num
	for x in range(num):
		g_num+=1
	print("work1:"+str(g_num))

def work2(num):
	global g_num
	for x in range(num):
		g_num+=1
	print("work2:"+str(g_num))

w1=threading.Thread(target=work1,args=(1000000,))
w1.start()

w2=threading.Thread(target=work2,args=(1000000,))
w2.start()

while len(threading.enumerate())!=1:
	time.sleep(1)
	
print("2个线程对同⼀个全局变量操作之后的最终结果是:%s" % g_num)

运行结果

正常结果应该是 2000000 ，但因为资源抢占，最后导致计算少了很多，此结果会随每一次运行会产生不同的遗漏计算值

线程同步

同步就是协同步调，按预定的先后次序进行运行，计算错误的问题，可以通过线程同步来进行解决。

互斥锁

互斥锁为资源引入一个状态：锁定/非锁定
某个线程要更改共享数据时，先将其锁定，此时资源的状态为“锁定”，其他线程不能更改；直到该线 程释放资源，将资源的状态变成“非锁定”，其他的线程才能再次锁定该资源。互斥锁保证了每次只有 一个线程进行写入操作，从而保证了多线程情况下数据的正确性。

# 创建锁 
mutex = threading.Lock() 
# 锁定 
mutex.acquire() 
# 释放 
mutex.release()

修改后代码

import threading
import time

g_num=0
mutex=threading.Lock()
def work1(num):
	global g_num
	for x in range(num):
		mutex.acquire()
		g_num+=1
		mutex.release()
	print("work1:"+str(g_num))

def work2(num):
	global g_num
	for x in range(num):
		mutex.acquire()
		g_num+=1
		mutex.release()
	print("work2:"+str(g_num))

w1=threading.Thread(target=work1,args=(1000000,))
w1.start()

w2=threading.Thread(target=work2,args=(1000000,))
w2.start()

while len(threading.enumerate())!=1:
	time.sleep(0.5)
	
print("2个线程对同⼀个全局变量操作之后的最终结果是:%s" % g_num)

运行结果

线程死锁

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

import threading
import time


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

class Thread_1(threading.Thread):
	"""docstring for Thread_1"""
	def run(self):
		#A上锁
		mutexA.acquire()
		#延迟等待另一个线程上锁
		print(self.name+"A Lock")
		time.sleep(1)

		#发生堵塞
		mutexB.acquire()
		print(self.name+"B Lock")
		mutexB.release()
		print(self.name+"B Release")
		mutexA.release()
		print(self.name+"A Release")

class Thread_2(threading.Thread):
	"""docstring for Thread_1"""
	def run(self):
		#B上锁
		mutexB.acquire()
		#延迟等待另一个线程上锁
		print(self.name+"B Lock")
		time.sleep(1)

		#发生堵塞
		mutexA.acquire()
		print(self.name+"A Lock")
		mutexA.release()
		print(self.name+"A Release")
		mutexB.release()
		print(self.name+"B Release")

t1=Thread_1()
t2=Thread_2()
t1.start()
t2.start()

运行结果

进入死锁状态，线程无法结束，程序无法继续运行