Python线程相关

最新推荐文章于 2021-08-13 18:07:57 发布

Liu Zhian

最新推荐文章于 2021-08-13 18:07:57 发布

阅读量167

点赞数 1

分类专栏： Python 文章标签： Python线程相关

Python 专栏收录该内容

8 篇文章 1 订阅

订阅专栏

一、threading 模块：对线程的处理

2-9 Thread + Lock 实现线程“互斥锁”

2-10 Thead + Semaphore 实现 “信号量”

2-11 Thread + Event 实现 “事件”

三、Timer 组件：定时器，n秒后执行操作

一、threading 模块：对线程的处理

multiprocess模块的完全模仿了threading模块的接口，二者在使用层面，有很大的相似性；

官方链接

二、Thread组件

2-1 开启线程的方式一（函数）


 
 
   
   
    
    
   
   
   
   
    
    
     
     from threading 
     
     import Thread
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     import time
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     def task(name):
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         print(
     
     '%s is running' % name)
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         time.sleep(
     
     2)
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         print(
     
     '%s is done' % name)
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     if __name__ == 
     
     '__main__':
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         t = Thread(target=task, args=(
     
     '线程1',))
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         t.start()
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         print(
     
     'main')

2-2 开启线程的方式二（类）


 
 
   
   
    
    
   
   
   
   
    
    
     
     from threading 
     
     import Thread
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     import time
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     class Mythread(Thread):
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
        
     
     def run(self):
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             print(
     
     '%s is running' % self.name)
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             time.sleep(
     
     2)
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             print(
     
     '%s is done' % self.name)
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     if __name__ == 
     
     '__main__':
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         t = Mythread()
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         t.start()
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         print(
     
     'main')

2-3 Thread 相关内置子方法

obj.isAlive():返回线程是否为活动状态
obj.getName():返回线程名
obj.setName():设置线程名
threading.currentThread():返回当前的线程变量
threading.enumerate():返回一个包含正在运行的线程list，即线程启动后、结束前，不包括启动前和终止后的线程。
threading.actibeCount():返回正在运行的线程数量，同 len ( threading.enumerate ( ) )


 
 
   
   
    
    
   
   
   
   
    
    
     
     from threading 
     
     import Thread
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     import threading
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     from multiprocessing 
     
     import Process
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     import os
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     def work():
    
    
   
   

   
   
    
    
   
   
   
   
    
        
     
     import time
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         time.sleep(
     
     3)
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         print(threading.current_thread().getName())
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     if __name__ == 
     
     '__main__':
    
    
   
   

   
   
    
    
   
   
   
   
    
        
     
     #在主进程下开启线程
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         t=Thread(target=work)
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         t.start()
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         print(threading.current_thread().getName())
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         print(threading.current_thread()) 
     
     #主线程
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         print(threading.enumerate()) 
     
     #连同主线程在内有两个运行的线程
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         print(threading.active_count())
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         print(
     
     '主线程/主进程')
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
        
     
     '''
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         打印结果:
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         MainThread
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         <_MainThread(MainThread, started 140735268892672)>
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         [<_MainThread(MainThread, started 140735268892672)>, <Thread(Thread-1, started 123145307557888)>]
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         主线程/主进程
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         Thread-1
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         '''

2-4 主进程等待新建线程实例


 
 
   
   
    
    
   
   
   
   
    
    
     
     from threading 
     
     import Thread
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     import time
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     def sayhi(name):
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         time.sleep(
     
     2)
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         print(
     
     '%s say hello' %name)
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     if __name__ == 
     
     '__main__':
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         t=Thread(target=sayhi,args=(
     
     'egon',))
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         t.start()
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         t.join()
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         print(
     
     '主进程')
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         print(t.is_alive())
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
        
     
     '''
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         >>>egon say hello
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         >>>主进程
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         >>>False
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         '''

2-5 线程共用创造进程内资源


 
 
   
   
    
    
   
   
   
   
    
    
     
     from threading 
     
     import Thread
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     n = 
     
     100
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     def task():
    
    
   
   

   
   
    
    
   
   
   
   
    
        
     
     global n
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         n = 
     
     0
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     if __name__ == 
     
     '__main__':
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         t = Thread(target=task)
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         t.start()
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         t.join()
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         print(
     
     '主', n)
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     '''
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     >>>主 0
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     '''

2-7 查看线程和‘父’进程的pid


 
 
   
   
    
    
   
   
   
   
    
    
     
     from threading 
     
     import Thread
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     import os
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     def task():
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         print(
     
     '%s is running' % os.getpid())
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     if __name__ == 
     
     '__main__':
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         t = Thread(target=task)
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         t.start()
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         print(
     
     '主', os.getpid())
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     '''
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     >>>14488 is running
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     >>>主 14488
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     '''

2-8 Thread 实现 “守护线程”

2-8-1 守护线程概念介绍

守护线程：守护线程会等待主进程内，所有非守护线程，全部运行完毕后，才进行销毁。即，等待进程结束。

2-8-2 实现简单 ‘守护线程’


 
 
   
   
    
    
   
   
   
   
    
    
     
     from threading 
     
     import Thread
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     import time
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     def foo():
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         print(
     
     123)
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         time.sleep(
     
     1)
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         print(
     
     "end123")
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     def bar():
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         print(
     
     456)
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         time.sleep(
     
     3)
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         print(
     
     "end456")
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     t1 = Thread(target=foo)
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     t2 = Thread(target=bar)
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     t1.daemon = 
     
     True
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     t1.start()
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     t2.start()
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     print(
     
     "main-------")
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     '''
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     >>>123
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     >>>456
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     >>>main-------
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     >>>end123
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     >>>end456
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     '''

2-9 Thread + Lock 实现线程“互斥锁”


 
 
   
   
    
    
   
   
   
   
    
    
     
     from threading 
     
     import Thread, Lock
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     import time
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     mutex = Lock() 
     
     # 每个线程内创建一把锁
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     n = 
     
     100
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     def task():
    
    
   
   

   
   
    
    
   
   
   
   
    
        
     
     global n
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
        
     
     # 加锁操作
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
        
     
     # mutex.acquire()
    
    
   
   

   
   
    
    
   
   
   
   
    
        
     
     # temp = n
    
    
   
   

   
   
    
    
   
   
   
   
    
        
     
     # time.sleep(0.1)
    
    
   
   

   
   
    
    
   
   
   
   
    
        
     
     # n = temp - 1
    
    
   
   

   
   
    
    
   
   
   
   
    
        
     
     # mutex.release()
    
    
   
   

   
   
    
    
   
   
   
   
    
        
    
    
   
   

   
   
    
    
   
   
   
   
    
        
     
     with mutex:
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             temp = n
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             time.sleep(
     
     0.1)
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             n = temp - 
     
     1
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     if __name__ == 
     
     '__main__':
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         t_l = []
    
    
   
   

   
   
    
    
   
   
   
   
    
        
     
     for i 
     
     in range(
     
     100):
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             t = Thread(target=task)
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             t_l.append(t) 
     
     # 添加线程对象
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             t.start()
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
        
     
     # 等待每一个线程结束
    
    
   
   

   
   
    
    
   
   
   
   
    
        
     
     for t 
     
     in t_l:
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             t.join()
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         print(n)

2-10 Thead + Semaphore 实现 “信号量”

信号量：保证只有指定数量线程，才能进行连接资源操作。
Semaphore：内部管理一个计数器，每次调用acquire()时+1，每次release()时-1.保证了每次连接的指定数量。


 
 
   
   
    
    
   
   
   
   
    
    
     
     from threading 
     
     import Thread,Semaphore
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     import time,random
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     sm=Semaphore(
     
     5)
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     #设置信号量允许连接数
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     def task(name):
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         sm.acquire()
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         print(
     
     '%s 正在使用' %name)
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         time.sleep(random.randint(
     
     1,
     
     3))
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         sm.release()
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     if __name__ == 
     
     '__main__':
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
        
     
     for i 
     
     in range(
     
     20):
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             t=Thread(target=task,args=(
     
     '路人%s' %i,))
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             t.start()

2-11 Thread + Event 实现 “事件”

事件：设置面向线程的一个信号标志，控制线程的执行
Event对象
- 包含一个由线程设置的信号标志，允许线程等待事件发生。
- 在初始状态下，信号标志为False。
- 如果存在线程等待Event对象，则Event对象的标志为False，线程将被阻塞至对象标志改变为True。
- 如果一个线程等待一个标志为True的Event对象，那么线程将忽略此事件对象，继续执行。
Event对象内部方法
- event.isSet():返回event的状态
- event.wait():如果状态值==False，将阻塞线程
- event.set():如果event的状态值为True，所有阻塞池的线程激活进入就绪状态，等待操作系统调度
- event.clear():回复envent的状态为False


 
 
   
   
    
    
   
   
   
   
    
    
     
     from threading 
     
     import Thread,Event
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     import time
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     event=Event()
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     def light():
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         print(
     
     '红灯正亮着')
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         time.sleep(
     
     3)
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         event.set() 
     
     #绿灯亮
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     def car(name):
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         print(
     
     '车%s正在等绿灯' %name)
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         event.wait() 
     
     #等灯绿
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         print(
     
     '车%s通行' %name)
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     if __name__ == 
     
     '__main__':
    
    
   
   

   
   
    
    
   
   
   
   
    
        
     
     # 红绿灯
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         t1=Thread(target=light)
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         t1.start()
    
    
   
   

   
   
    
    
   
   
   
   
    
        
     
     # 车
    
    
   
   

   
   
    
    
   
   
   
   
    
        
     
     for i 
     
     in range(
     
     10):
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             t=Thread(target=car,args=(i,))
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             t.start()

三、Timer 组件：定时器，n秒后执行操作


 
 
   
   
    
    
   
   
   
   
    
    
     
     from threading 
     
     import Timer
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     def hello():
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         print(
     
     "hello, world")
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     t = Timer(
     
     1, hello)
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     t.start()  
     
     # after 1 seconds, "hello, world" will be printed