标签：

1.threading.Thread对象【创建线程的主要对象】：

方法：start()：启动线程

run()：启动线程后自动调用的方法

join([timeout])：等待到被调用的线程终止

is_alive()：返回线程活动状态

属性：name：线程名

ident：线程ID号

daemon：后台标志

2.创建线程的方法：

1:实例化threading.Thread对象

ths = threading.Thread( target = None, name = None, args = (), kwarg = {} )

传入函数名　 线程名 函数的参数

2:继承threading中的Thread对象后再实例化并启动

3.以不同的线程类型分：

令：t = threading.Thread(target=dmn...)，即是t为一个线程

3.1.独立线程：就是最简单的独立单线程

3.2.线程等待：t.join([timeout])，放到start()后，表明t线程执行完后(或是指定时间后)才轮到下一个线程【若是因为指定时间的话还会跳回t线程】

1 #coding:utf-8

2 importthreading, time3 classMyThread(threading.Thread):4

5 defrun(self):6 for i in range(40):7 print() #若是t线程在执行时就是打印换行

8 time.sleep(0.1)9

10 if __name__ == "__main__":11 t =MyThread()12 t.start()13 **t.join()**

14 for i in range(10): #此部分是主线程执行的,也就是说此程序有主线程与t线程两个线程

15 print("main:", i)16 time.sleep(0.1)17

18 #最后会在打印完了换行后才打印0到9的“main：...”, 说明t线程执行完了后主线程才执行的

线程等待示例

3.3.后台线程(在主线程退出后立即自杀)：设置daemon属性为True【 t.daemon = True】

3.4.线程同步：指的是多个线程同时需要用到的资源，此时为了保证一致性有多种不同的加锁处理机制【获取了锁的线程可以对此资源进行操作，而没有的线程处于阻塞状态】，如下：

1)先到先用---指令锁：threading.Lock对象

定义锁变量：lock = threading.Lock()

锁定资源：lock.acquire()

释放资源：lock.release()

1 importthreading, time, random2 share = 4

3 classMyThread(threading.Thread):4 def __init__(self,i):5 super().__init__()6 self.i =i7

8 defrun(self):9 globalshare10 for d in range(40):11 **lock.acquire()**

12 print(share)13 share +=self.i14 time.sleep(random.random())15 print("t+", self.i, "=", share)16 **lock.release()**

17

18 **lock = threading.Lock()**

19

20 if __name__ == "__main__":21 t = MyThread(2)22 tt = MyThread(6)23 t.start()24 #t.join()

25 tt.start()26

27 #会看到一会儿加2，一会儿加6

28 #若将倒数第二行注释去除，则一直加2，完了后才加6

指令锁示例

2)可重入锁：被某一线程锁定了后还可以被其他线程锁定

3)有先后顺序的使用---条件变量：threading.Condition对象(创建了一个带锁的线程池), [当具备了某条件后才调用某线程，如生产者-消费者模式]

定义锁变量：conLock = threading.Condition()

获得锁：conLock.acquire()

通知线程池里其他线程：conLock.notify( [ n=x ] )【唤起x个,默认为1】，clock.notify_all()【唤醒全部】

释放锁并且进入线程池等待：conLock.wait()

1 #coding:utf-8

2 importthreading, time3 share =04 **share_condition = threading.Condition()**

5

6 classProductThread(threading.Thread):7 def __init__(self):8 super().__init__()9 self.name = "生产者"

10

11 defrun(self):12 globalshare13 ifshare_condition.acquire():14 whileTrue:15 if notshare:16 share += 1

17 print( self.name, share )18 **share_condition.notify()** #执行线程池里的一个等待线程

19 **share_condition.wait()** #当前线程释放锁并将当前线程放入线程池等待下次notify()，所以如果没有此句则只会显示一句“生产者：1”

20 time.sleep(1)21

22 classCustumerThread(threading.Thread):23 def __init__(self):24 super().__init__()25 self.name = "消费者"

26

27 defrun(self):28 globalshare29 ifshare_condition.acquire():30 whileTrue:31 ifshare:32 share -= 1

33 print( self.name, share )34 **share_condition.notify()**

35 **share_condition.wait()**

36 time.sleep(1)37

38 lock =threading.Lock()39

40 if __name__ == "__main__":41 product =ProductThread()42 customer =CustumerThread()43 product.start()44 customer.start()45

46

47 #最后会相继打印：

48 #生产者 1

49 #消费者 0

条件变量锁机制示例

4)部分线程同时使用---信号量：threading.Semaphore对象

定义锁：sema = threading.Semaphore(n) #允许同时有n个线程获得锁

获得锁：sema.acquire()

释放锁：sema.release()

常用于限制资源的访问，比如数据库的连接池

1 #coding:utf-8

2 importthreading, time3 classMyThread(threading.Thread):4 def __init__(self,name):5 super().__init__()6 self.name =name7

8 defrun(self):9 ifsema.acquire():10 print(self.name,"得到了锁")11 time.sleep(1)12 sema.release()13 print(self.name,‘释放了锁‘)14

15 sema = threading.Semaphore(2)16

17 if __name__ == "__main__":18 threads = [ MyThread(str(i)+"sema") for i in range(5) ]19 for thread inthreads:20 thread.start()21

22 #输出如下，可以看出同时能够有两个线程获得了锁

23 #0sema 得到了锁

24 #1sema 得到了锁

25 #0sema 释放了锁

26 #1sema 释放了锁

27 #2sema 得到了锁

28 #3sema 得到了锁

29 #2sema 释放了锁

30 #4sema 得到了锁

31 #3sema 释放了锁

32 #4sema 释放了锁

信号量锁示例

5)线程间通信---threading.Event对象(创建了一个带有标志的线程池,当一个线程设置内部标志为True后线程池中的等待线程就会被唤醒并执行)【即是当前执行线程可以决定啥时候(一般是所共同使用的资源已经使用完毕了后)“叫醒”别的线程，需要注意的是，若此时叫醒别人的线程并没有wait进入线程池，那么如果其还有代码的话将继续执行下去】

定义锁变量： event = threading.Event()

进入线程池等待：event.wait([timeout])

设置内部标志为True：event.set() event.clear()

1 #coding:utf-8

2 importthreading, time3

4 classWaitThread(threading.Thread):5

6 defrun(self):7 self.name = "等待线程"

8 print(self.name,"正在等待") #注意此程序的执行顺序，先调用的此线程执行到这里

9 **event.wait()** #在此此线程wait进入线程池等待，切换到mainThread直至设置标志

10 print(self.name,"启动了") #从而此线程在此被唤醒执行

11 **event.clear()** #而后设置标志为false

12

13 classMainThread(threading.Thread):14

15 defrun(self):16 time.sleep(3)17 print("主线程更改了标志")18 **event.set()**

19 print("这里的会在WaitThread打印启动了前打印吗？")20

21 **event = threading.Event()**

22

23 if __name__ == "__main__":24 wt =WaitThread()25 mt =MainThread()26 wt.start()27 mt.start()28

29 #输出：

30 #等待线程 正在等待

31 #主线程更改了标志

32 #这里的会在WaitThread打印启动了前打印吗？

33 #等待线程 启动了

线程间通信锁示例

*补充.关于定时执行：threading.Timer()

标签：