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