python互斥锁问题_多线程与全局变量以及互斥锁死锁的问题

可以解决爬虫问题

同一个进程中，所有的线程共享全局变量

1，函数里面修改全局变量

num=100

num=[11,22]

def test1():

global num#声明全局变量

num+=100

def test2():

nums.append(33)

num+=100

print(num)

print(nums)

test1()

test2()

print(num)

print(nums)

#两次打印num的结果不一样

什么时候加 global: 需要修改全局变量的时候加global

在一个函数中对全局变量进行修改时，到底是用global进行说明，要看是否对全局变量的执行只想进行修改。

如果修改了执行，即让全局变量只指向一个新的地方，那么必须使用global.

如果仅仅是修改了只想的空间中的数据，此时不用加。

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.Thread(target=test1)

t2 = threading.Thread(target=test2)

t1.start()

time.sleep(1)#为了先让test1执行完

t2.start()

time.sleep(1)#为了先让test2执行完

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

#等子线程2和子线程2执行完后执行主线程

if __name__ == '__main__':

main()

#子线程与主线程共享全局变量

-----in test1 g_num=101----

-----in test2 g_num=101----

-----in main thread g_num=101----

import threading

import time

def test1(temp):

temp.append(33)

print('-----in test1 temp={}----'.format(temp))

def test2(temp):

print('-----in test2 temp={}----'.format(temp))

g_nums= [11,22]

def main():

#target指定这个线程去哪个函数执行代码

#args指定将来调用函数的时候传递什么数据过去

t1 = threading.Thread(target=test1,args=(g_nums,))#args必须是元组

t2 = threading.Thread(target=test2,args=(g_nums,))

t1.start()

time.sleep(1)#为了先让test1执行完

t2.start()

time.sleep(1)#为了先让test2执行完

print('-----in main thread g_nums={}----'.format(g_nums))

#等子线程2和子线程2执行完后执行主线程

if __name__ == '__main__':

main()

#验证了多线程之间共享全局变量

-----in test1 temp=[11, 22, 33]----

-----in test2 temp=[11, 22, 33]----

-----in main thread g_nums=[11, 22, 33]----

2，共享全局变量会发生的问题

多线程任务开发会发生的问题：资源竞争

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():

global g_num

for i in range(num):

g_num += 1

print('-----in test1 g_num=%d----' % g_num)

def main():

t1 = threading.Thread(target=test1,args=(100,))

t2 = threading.Thread(target=test2,args=(100,))

t1.start()

t2.start()

#等待上面的两个线程执行完毕

time.sleep(5)

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

if __name__ == '__main__':

main()

#子线程与主线程共享全局变量

-----in test1 g_num=101----

-----in test2 g_num=101----

-----in main thread g_num=101----

import threading

互斥锁：

互斥锁的优点和缺点：

优点：确保某段关键代码只能有一个线程从头到尾完整的执行。

缺点：阻止了多线程并发执行，包含锁的某段代码实际上只能以单线程并发执行，效率就大大的下降了；由于可以存在多个锁，不同的线程持有不同的锁，并试图获取对方持有的锁是，可能会造成死锁。**

#锁放在for循环外面，结果不会错

import threading

num=0

def sub(l):

global num

l.acquire()

for i in range(100000):

num += 1

l.release()

print(num)

def bus(l):

global num

l.acquire()

for i in range(100000):

num += 1

l.release()

print(num)

def main():

l=threading.Lock()

t1=threading.Thread(target=sub,args=(l,))

t2=threading.Thread(target=bus,args=(l,))

t1.start()

t2.start()

if __name__ == '__main__':

main()

100000

200000

#锁放在for循环里面，还是会出错

import threading

num=0

l=threading.Lock()

def sub(sum):

global num

for i in range(sum):

l.acquire()

num += 1

l.release()

print(num)

def bus(sum):

global num

for i in range(sum):

l.acquire()

num += 1

l.release()

print(num)

def main():

t1=threading.Thread(target=sub,args=(100000,))

t2=threading.Thread(target=bus,args=(100000,))

t1.start()

t2.start()

if __name__ == '__main__':

main()

170862

200000

死锁：两个或两个以上的线程或进程再执行的时候，由于资源竞争而造成的互相等待的现象。

import threading

num=0

def sub(a):

global num

a.acquire()

for i in range(1000000):

num += 1

a.release()

print(num)

def bus(b):

global num

b.acquire()

for i in range(1000000):

num += 1

b.release()

print(num)

def main():

a=threading.Lock()

b=threading.Lock()

t1=threading.Thread(target=sub,args=(a,))

t2=threading.Thread(target=bus,args=(b,))

t1.start()

t2.start()

if __name__ == '__main__':

main()

1278667

1343790

怎么避免死锁：

添加超时时间

程序设计时避免(银行家算法)

#添加超时时间

import threading

import time

num=0

def sub(a):

global num

a.acquire()

for i in range(1000000):

num += 1

a.release()

print(num)

def bus(b):

global num

b.acquire()

for i in range(1000000):

num += 1

b.release()

print(num)

def main():

a=threading.Lock()

b=threading.Lock()

t1=threading.Thread(target=sub,args=(a,))

t2=threading.Thread(target=bus,args=(b,))

t1.start()

time.sleep(3)#添加超时时间

t2.start()

if __name__ == '__main__':

main()

1000000

2000000

银行家算法(Banker’s Algorithm)是一个避免死锁(Deadlock)的著名算法，是由艾兹格·迪杰斯特拉在1965年为T.H.E系统设计的一种避免死锁产生的算法。它以银行借贷系统的分配策略为基础，判断并保证系统的安全运行。 [1]

​

原文链接:https://blog.csdn.net/JIENIXIAOWU/article/details/108366253