Python数据库 7.线程与线程池

时间：2021-12-04 04:43:47

7.1线程

常用参数鋭明

target 表示凋用対象，即子袋程要抗行的任努name   子銭程的名称
args 侍入target函数中的位置参数，是一个元組，参数后必須加逗号

常用实例方法：

  • 1.Thread.run (self)

    线程启动时运行的方法 ,由该方法调用target参数所指定的函数。

  • 2.Thread,start (self)

    启动进程，start方法就是 去帮你调用run方法。

  • 3.Thread, terminate (self)

    强制终止线程

  • 4.Thread.join (self, timeout=None)

    阻塞调用，主线程进行等待。

  • 5.Thread. setDaeman (self , daemonic)

    将子线程设置为守护线程。

  • 6.Thread . getName (self，name)

    获取线程名称Thread，setName (self, name) 设置线程名称

 

7.2 线程流程

  • 1.主线程 :

    当一个程序启动时 , 就有一个线程开始运行 , 该线程通常叫做程序的主线程

  • 2.子线程 :

    因为程序是开始时就执行的 , 如果你需要再创建线程 , 那么创建的线程就是这个主线程的子线程

  • 3.主线程的重要性体现在两方面 :

    1. 是产生其他子线程的线程

    2. 通常它必须最后完成执行比如执行各种关闭操作

  • join :

    阻塞调用程序 , 直到调用join () 方法的线程执行结束, 才会继续往下执行

###### for i in range(10): 创建线程 开始线程 for i in range(10): 阻塞线程 ######

 

?
 import time 
 from threading import Thread
 
 def hello (name):
  print (‘hello,{}‘.format(name))  #传参数传的是 元组
  time.sleep(3)
  print (‘666‘)
 
 def hi ():
  print (‘wuchi‘)
  time.sleep(3)
  print (‘888‘)
 
 if __name__ == ‘__main__‘:
  hello_thread = Thread(target = hello,args=())  #函数名
 
  hi_thread = Thread(target = hi)  
 
 
  hello_thread.start()
  hi_thread.start()
 
 
  hello_thread.join()
  hi_thread.join()
?
?
##############
?
?
 class MyThread( Thread):
 
  def__ init__ (self, people_ name, *args, **kwargs):
 
   super( ).__ init__ ( *args, **kwargs)
   self.people_name = people_name
 
  def run( self):
 
   print( ‘hello, {}‘.format(self.people_name))time .sleep(3)
   print( ‘byebye‘ )
 
 my_ thread = MyThread( ‘手段‘ , name= ‘打打是‘ )
 print(my_thread. getName( ))
 my_thread.start( ) .
 
?
?
?
?
?
?

锁 

?
 from threading import Thread,Lock
 
 X=0
 n = 1000000
 lock = Lock( )
 
 def incr(n):
  global x
  for i in range(n):
   lock. acquire()
   X =1
   lock. release()
 
 def decr(n):
  global x
  for i in range(n):
   lock . acquire( )
   X-=1
   lock. release()
?
 i = Thread(target=incr, args=(n,))
 d = Thread( target=decr, args=(n,))
?
 i.start( )
 d.start( )
 i. join()
 d.join()
 
 print(x)
?

队列

 

入队： put(item)
出队： get()
测试空： empty() # 近似 
测试满： full() # 近似
队列长度： qsize() # 近似
等待完成： join()
任务结束： task_done()
?
 from threading import Thread,Lock
 from queue import Queue ‘
 from random import randint
 
 
 my_queue = Queue(10)
 
 def incr(my_queue):
  for i in range(10):
    num. randint(0,1000)
  my_queue. put(num)
 
 def decr(my_queue ):
    for i in range(5):
    num . my_queue.get()
  myPqueue.task_done()
  print( num)
 
 i = Thread( target=incr, args=(my_queue,))
 d = Thread(target-decr, args=(my_queue,))
 
 i.start( )
 d.start( )
 i.join( )
 d.join()
?
?

 

7.3 线程池

 

?
 from multiprocessing.pool import ThreadPool 
 class ThreadPool(object):
  def __init__ ( self, n):
   self.q = Queue( )
   for i in range(n):
    Thread( target=self. worker, daemon= True).start( )
 
  def worker(self):
   while True:
    func, args, kwargs = self.q.get()
    func( *args, **kwargs )
    self.q.task_done()
 
  def put(self, target, args=( ), kwargs={} ):
   self.q.put((target, args, kwargs)) 
 
  def join(self):
   self.q. join()
 
 
 def hello( name):
  print(‘hello, lf‘. format( name) )
  time .sleep(2)
  print( ‘ byebye‘)
 
 tp = ThreadPool(5)
 for i in range(10):
  tp.put(hello, args=(i,))
 tp. join( )
?
?
?
##########################
?
?
    def hello(name):
    print( ‘hello, f]‘. format( name))
  time . sleep(2)
  print( ‘ byebye‘ )
?
    tp = ThreadPool(10)
 for i in range(10): .
?
    tp. apply_ async(hello, args=(i,))
?
    # tp. terminate() 
 tp. close( )
    tp. join( )I

相关文章