3.7 学网络编程 threading线程的join deamon方法 锁,死锁,递归锁

#join 阻塞的是所在的地方，等待线程结束才继续向下执行
import threading
import time
def foo(n):
print('yanga11ang,foo%s'%n)
time.sleep(3)
def bar(n):
print('bar%s'%n)
time.sleep(2)
#第一种直接调用方式，先创建线程
t1=threading.Thread(target=foo,args=(1,))
t2=threading.Thread(target=bar,args=(2,))
t1.setDeamon(True) # 守护线程，主进程结束，子线程就会结束，
t1.start()
t2.start()
t1.join() #t1结束了才能继续

threading.current_thread() # 线程的名字，区分各个子线程和主线程
threading.active_count() #活着的线程，包含主线程

#第二种用类来创造线程
import threading
import time
class Mythread(threading.Thread):
def __init__(self,num):
threading.Thread.__init__(self)
self.num=num

def run(self):
prin('running on number:%s'%self.num)
time.sleep(3)

import time
import threading
def addNum():
global num
num-=1
#temp=num
#num=temp-1
#time.sleep(1)

num=100
thread_list=[]
for i in range(100):
t=threading.Thread(target=addNum)
t.start()
thread_list.append(t)

for t in thread_list:
t.join()
print(num) #0
#如果把函数换成#的,不一定还是0

#解决方案 加锁
r=threading.Lock()
def addNum():
global num
r.acquire() #加锁
temp=num
num=temp-1
time.sleep(1)
r.release() #解锁  线程不会在用切换到同样的锁的线程
#------------------------------------------------------
import threading,time
class myThread(threading.Thread):
def __init__(self,name):
self.name=name
def doA(self):
lockA.acquire()
#lock.acquire()
print(self.name,'gotlockA',time.ctime())
time.sleep(3)
lockB.acquire()
#lock.acquire() #lock 两次的意义: 锁住他调用的函数,防止被修改
print(self.name,'gotlockB',time.ctime())
lockB.release()
#lock.acquire()
lockA.release()
#lock.acquire()

def doB(self):
lockB.acquire() #如果b锁没有没用到的话,它可以用线程
#lock.acquire()
print(self.name,'gotlockB',time.ctime())
time.sleep(2)
lockA.acquire()
#lock.acquire()
print(self.name,'gotlockA',time.ctime())
lockA.release()
#lock.acquire()
lockB.release()
#lock.acquire()
def run(self):
self.doA()
self.doB()
lockA=threading.Lock()
lockB=threading.Lock() #可能会造成死锁现象
#lock=threading.RLock() #所有的锁都一样

threads=[]
for i in range(5):
thread.