可以解决爬虫问题
同一个进程中,所有的线程共享全局变量
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