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

标签：uil   opera   程序启动   soft   一个   async   rop   comm   进程池   

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
?
?
操作一： close - 关闭提交通道，不允许再提交任务
?
操作二： terminate - 中止进程池，中止所有任务 
?
?
?

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

标签：uil   opera   程序启动   soft   一个   async   rop   comm   进程池   

原文地址：https://www.cnblogs.com/dyf25288-/p/11701601.html