学习笔记一：多线程
1.线程是程序执行的最小单位，而进程是操作系统分配资源的最小单位
2.一个进程有一个或多个线程组成，线程是一个进程中代码不同执行路线
3.进程之间相互独立，但同一进程下的各个线程之间共享程序的存空间（包括代码段，数据集，堆等）及一些进程级的资源（如打开文件和信息等），某进程内的线程在其他进程不可见
4.调度和切换：线程上下问切换比进程上下文切换要快的多
创建多线程：
class myThread(threading.Thread):
def __init__(self,name):
super(myThread2, self).__init__()#继承
self.name=name#定义属性
def run(Self):
print('以类的方式创建多线程',self.n)
r1=MyThread(11)
r2=MyThread(22)
r1.start()
r2.start()
多线程特性：
查看当前线程：
threading.current_thread()
查看活动的线程：
threading.active_count()
计算线程运行的时间：
#time.time()获取当前时间
start_time=time()
#线程运行代码
#获取运行时间
time=time.time()-start_time
学习笔记二：线程锁threading.Lock
锁(Lock):一旦线程获得锁，其他试图获取锁的线程将被阻塞等待。
锁：凡是存在共享支援争抢的地方都可以使用锁，从而保证只有一个使用者可以完全使用这个资源。
Lock.acquire（）：获得锁
Lock.release(); 释放锁
import threading
def run():
global x
Lock.acquire()#获得锁，保证每次只有一个线程操作x的值
x+=1 #对x进行操作
lock.release()#释放锁
if __name__=='__main__':
x=0
res=[]
lock=threading.Lock()
for i in range(100):
t=threading.Thread(target=run)
t.start()
res.append(t)
for t in res:
t.join() #等待线程结束
print(x)
学习笔记三：递归锁
递归锁 其实就是维护一个计数器 比如A 线程 获得了锁 那么计数器会+1? 释放的时候 为0? 如果这个计数器不为0? 那么其他的线程无法获得锁 只能慢慢的等待
#lock = threading.Lock() 时,程序会卡死在这
#lock = threading.Rlock()递归锁,维护一个计时器,acquire+1 release-1,程序就能正常运行
2 import threading,time
3
4
5 def run1():
6 print("grab the first part data")
7 # 申请锁
8 lock.acquire()
9 # 将全局的变量，在此声明一下
10 global x
11 x += 1
12 # 释放锁
13 lock.release()
14 return x
15 def run2():
16 print("grab the second part data")
17 lock.acquire()
18 global y
19 y += 1
20 lock.release()
21 return y
22 def run3():
23 lock.acquire()
24 res = run1()
25 print("between run1 and run2")
26 res2 = run2()
27 lock.release()
28 print(res,res2)
29
30 if __name__ == "__main__":
31 num,num2 = 0,0
32 # 递归锁
33 lock = threading.RLock()#lock = threading.Lock() 时,程序会卡死在这里
#Rlock()递归锁,维护一个计时器,acquire+1 release-1,程序就能正常运行
34 for i in range(10):
35 t = threading.Thread(target=run3)
36 t.start()
37
38 while threading.active_count() != 1:
39 print(threading.active_count())
40
41 else:
42 print("all threads done")
43 print(x,y)
|