zoukankan      html  css  js  c++  java
  • 线程threading模块

    什么是线程?

    在传统操作系统中,每个进程有一个地址空间,而且默认就有一个控制线程

    线程顾名思义,就是一条流水线工作的过程(流水线的工作需要电源,电源就相当于cpu),而一条流水线必须属于一个车间,一个车间的工作过程是一个进程,车间负责把资源整合到一起,是一个资源单位,而一个车间内至少有一条流水线。

    所以,进程只是用来把资源集中到一起(进程只是一个资源单位,或者说资源集合),而线程才是cpu上的执行单位。

    多线程(即多个控制线程)的概念是,在一个进程中存在多个线程,多个线程共享该进程的地址空间,相当于一个车间内有多条流水线,都共用一个车间的资源。例如,北京地铁与上海地铁是不同的进程,而北京地铁里的13号线是一个线程,北京地铁所有的线路共享北京地铁所有的资源,比如所有的乘客可以被所有线路拉。

    线程和进程的区别

    1. 同一个进程内的多个线程共享该进程内的地址资源
    2. 创建线程的开销要远小于创建进程的开销(创建一个进程,就是创建一个车间,涉及到申请空间,而且在该空间内建至少一条流水线,但创建线程,就只是在一个车间内造一条流水线,无需申请空间,所以创建开销小)

    在主进程下创建子进程,由于创建进程的开销较大,所以在p.start()的时候是向操作系统申请一块空间,不会立刻的就将进程开启。

    而在主线程下创建子线程,由于线程是存在于进程中的,且线程间是共享进程内的资源的,创建线程不需要申请内存空间,消耗很小,t.start()的瞬间就创建了线程。

    每个子进程创建出来后内存空间都是相互隔离的,资源不共享,且每个子进程都有不同的pid号,ppid号是创建其的父进程Pid号。

    每个子线程的pid号就是主线程的pid号

    多线程应用举例

    开启一个字处理软件进程,该进程肯定需要办不止一件事情,比如监听键盘输入,处理文字,定时自动将文字保存到硬盘,这三个任务操作的都是同一块数据,因而不能用多进程。只能在一个进程里并发地开启三个线程,如果是单线程,那就只能是,键盘输入时,不能处理文字和自动保存,自动保存时又不能输入和处理文字。

    threading.Thread

    Thread 是threading模块中最重要的类之一,可以使用它来创建线程。有两种方式来创建线程:一种是通过继承Thread类,重写它的run方法;另一种是创建一个threading.Thread对象,在它的初始化函数(__init__)中将可调用对象作为参数传入。下面分别举例说明。先来看看通过继承threading.Thread类来创建线程的例子:

    import threading
    
    a = 0
    class MYThread(threading.Thread):#继承类threading.Thread
        def __init__(self,lock):
            super(MYThread, self).__init__()#调用父类__init__()方法
            self.lock = lock
    
        def run(self):
            global a
            with self.lock:
                for i in range(100):
                    a += 1
    
    if __name__ == '__main__':
        lock = threading.Lock()
        l = []
        for i in range(5):
            t = MYThread(lock)
            l.append(t)
    
        for i in l:
            i.start()
    
        for i in l:
            i.join()
        print(a)
    

    另外一种创建线程的方法

    import threading
    
    a = 0
    def run(self):
        global a
        with lock:
            for i in range(100):
                a += 1
    
    if __name__ == '__main__':
        lock = threading.Lock()
        l = []
        for i in range(5):
            t = threading.Thread(target=run,args=(lock,))
            l.append(t)
    
        for i in l:
            i.start()
    
        for i in l:
            i.join()
        print(a)
    

      

    threading.Thread初始化函数原型

    def __init__(self, group=None, target=None, name=None, args=(), kwargs={})
    
      参数group是预留的,用于将来扩展;
      参数target是一个可调用对象(也称为活动[activity]),在线程启动后执行;
      参数name是线程的名字。默认值为“Thread-N“,N是一个数字。
      参数args和kwargs分别表示调用target时的参数列表和关键字参数。
    

      

    Thread类还定义了一下常用方法与属性

    Thread实例对象的方法
      # isAlive(): 返回线程是否活动的。
      # getName(): 返回线程名。
      # setName(): 设置线程名。
     #join():主线程等待子线程运行完毕才运行
      #daemon = True:设置主线程的守护线程
    threading模块提供的一些方法:
      # threading.currentThread(): 返回当前的线程变量。
      # threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前,不包括启动前和终止后的线程。
      # threading.activeCount(): 返回正在运行的线程数量,与len(threading.enumerate())有相同的结果。


    threading.RLock和threading.Lock
    在threading模块中,定义两种类型的琐:threading.Lock和threading.RLock。它们之间有一点细微的区别,通过比较下面两段代码来说明:

    import threading
    lock = threading.Lock()    #Lock对象
    lock.acquire()
    lock.acquire()  #产生了死琐。
    lock.release()
    lock.release()
    
    
    import threading
    rLock = threading.RLock()  #RLock对象
    rLock.acquire()
    rLock.acquire()    #在同一线程内,程序不会堵塞。
    rLock.release()
    rLock.release()
    
    
    这两种琐的主要区别是:RLock允许在同一线程中被多次acquire。而Lock却不允许这种情况。注意:如果使用RLock,那么acquire和release必须成对出现,即调用了n次acquire,必须调用n次的release才能真正释放所占用的琐。
    
    Lock在acquire锁时如这把锁没有被release释放掉,则会堵塞直到释放后拿到锁。
    Rlock可以被多次的acquire但也针对于第一次拿到锁的线程,内部会有一个计数器计算着锁被acquire的次数,releace一次计数就减1,直到计数为零时其他的线程才能使用这把锁。
      

    守护线程、守护进程

    设置守护进程(线程)

    a(进程或者线程对象).daemon = True
    必须在start()之前设置
    

      

    无论是进程还是线程,都遵循:守护进程(线程)会等待主进程(线程)运行完毕后被销毁

    需要强调的是:运行完毕并非终止运行

    1、对主进程来说,运行完毕指的是主进程代码运行完毕
    
    2、对主线程来说,运行完毕指的是主线程所在的进程内所有非守护线程统统运行完毕,主线程才算运行完毕
    
    
    1、主进程在其代码结束后就已经算运行完毕了(守护进程在此时就被回收),然后主进程会一直等非守护的子进程都运行完毕后回收子进程的资源(否则会产生僵尸进程),才会结束,
    
    2、主线程在其他非守护线程运行完毕后才算运行完毕(守护线程在此时就被回收)。因为主线程的结束意味着进程的结束,进程整体的资源都将被回收,而进程必须保证非守护线程都运行完毕后才能结束。

      

     samaphore(信号量)

    信号量也是一把锁,可以指定信号量为5,对比互斥锁同一时间只能有一个任务抢到锁去执行,信号量同一时间可以有5个任务拿到锁去执行,如果说互斥锁是多人去抢一个东西,那么信号量就相当于一群人争抢多个物品,这意味着同一时间可以有多个人可以使用抢到的物品,但物品是一定的,这便是信号量的大小。

    from threading import Thread,Semaphore
    import threading
    import time
    
    def func():
        sm.acquire()
        print('%s get sm' %threading.current_thread().getName())
        time.sleep(3)
        sm.release()
    
    if __name__ == '__main__':
        sm=Semaphore(5)
        for i in range(23):
            t=Thread(target=func)
            t.start()
    
    
    Semaphore管理一个内置的计数器,
    每当调用acquire()时内置计数器-1;
    调用release() 时内置计数器+1;
    计数器不能小于0;当计数器为0时,acquire()将阻塞线程直到其他线程调用release()。
    

      

    threading.Condition

    可以把Condiftion理解为一把高级的琐,它提供了比Lock, RLock更高级的功能,允许我们能够控制复杂的线程同步问题。threadiong.Condition在内部维护一个琐对象(默认是RLock),可以在创建Condigtion对象的时候把琐对象作为参数传入。Condition也提供了acquire, release方法,其含义与琐的acquire, release方法一致,其实它只是简单的调用内部琐对象的对应的方法而已。Condition还提供了如下方法(特别要注意:这些方法只有在占用琐(acquire)之后才能调用,否则将会报RuntimeError异常。):

    Condition.wait([timeout]):

    wait方法释放内部所占用的琐,同时线程被挂起,直至接收到通知被唤醒或超时(如果提供了timeout参数的话)。当线程被唤醒并重新占有琐的时候,程序才会继续执行下去。

    Condition.notify():

    唤醒一个挂起的线程(如果存在挂起的线程)。注意:notify()方法不会释放所占用的琐。

    Condition.notify_all()

    Condition.notifyAll()

    唤醒所有挂起的线程(如果存在挂起的线程)。注意:这些方法不会释放所占用的琐。

    现在写个捉迷藏的游戏来具体介绍threading.Condition的基本使用。假设这个游戏由两个人来玩,一个藏(Hider),一个找(Seeker)。游戏的规则如下:1. 游戏开始之后,Seeker先把自己眼睛蒙上,蒙上眼睛后,就通知Hider;2. Hider接收通知后开始找地方将自己藏起来,藏好之后,再通知Seeker可以找了; 3. Seeker接收到通知之后,就开始找Hider。Hider和Seeker都是独立的个体,在程序中用两个独立的线程来表示,在游戏过程中,两者之间的行为有一定的时序关系,我们通过Condition来控制这种时序关系。

    import threading, time
    class Hider(threading.Thread):
        def __init__(self, cond, name):
            super(Hider, self).__init__()
            self.cond = cond
            self.name = name
        
        def run(self):
            time.sleep(1) #确保先运行Seeker中的方法   
            
            self.cond.acquire() 
            print (self.name + ': 我已经把眼睛蒙上了')
            self.cond.notify()
            self.cond.wait() 
                            
            print (self.name + ': 我找到你了 ~_~')
            self.cond.notify()
            self.cond.release()
                                #g
            print (self.name + ': 我赢了')  
            
    class Seeker(threading.Thread):
        def __init__(self, cond, name):
            super(Seeker, self).__init__()
            self.cond = cond
            self.name = name
        def run(self):
            self.cond.acquire()
            self.cond.wait()        #释放对琐的占用,同时线程挂起在这里,直到被notify并重新占
    有琐。
                             
            print (self.name + ': 我已经藏好了,你快来找我吧')
            self.cond.notify()
            self.cond.wait()    
                              
            self.cond.release() 
            print (self.name + ': 被你找到了,哎~~~')
           
    
    if __name__ == '__main__':
        cond = threading.Condition()
        seeker = Seeker(cond, 'seeker')
        hider = Hider(cond, 'hider')
        seeker.start()
        hider.start()
    

      

    threading.Event

    Event实现与Condition类似的功能,不过比Condition简单一点。它通过维护内部的标识符来实现线程间的同步问题。(threading.Event和.NET中的System.Threading.ManualResetEvent类实现同样的功能。)

    Event.wait([timeout])

    堵塞线程,直到Event对象内部标识位被设为True或超时(如果提供了参数timeout)。

    Event.set()

    将标识位设为Ture

    Event.clear()

    将标识伴设为False。

    Event.isSet()

    判断标识位是否为Ture。

    下面使用Event来实现捉迷藏的游戏

    import threading, time
    class Hider(threading.Thread):
        def __init__(self, cond, name):
            super(Hider, self).__init__()
            self.cond = cond
            self.name = name
        
        def run(self):
            time.sleep(1) #确保先运行Seeker中的方法   
            
            print (self.name + ': 我已经把眼睛蒙上了')
            
            self.cond.set()
            
            time.sleep(1)   
            
            self.cond.wait()
            print (self.name + ': 我找到你了 ~_~')
            
            self.cond.set()
                                
            print (self.name + ': 我赢了')
            
    class Seeker(threading.Thread):
        def __init__(self, cond, name):
            super(Seeker, self).__init__()
            self.cond = cond
            self.name = name
        def run(self):
            self.cond.wait()
                            
            print (self.name + ': 我已经藏好了,你快来找我吧')
            self.cond.set()
            
            time.sleep(1)
            self.cond.wait()
                                
            print (self.name + ': 被你找到了,哎~~~')
            
    if __name__ == '__main__':
        cond = threading.Event()
        seeker = Seeker(cond, 'seeker')
        hider = Hider(cond, 'hider')
        seeker.start()
        hider.start()
    

      

    threading.Timer

    threading.Timer是threading.Thread的子类,可以在指定时间间隔后执行某个操作。下面是Python手册上提供的一个例子:

    def hello():
        print "hello, world"
    t = Timer(3, hello)
    t.start() # 3秒钟之后执行hello函数。
    

    Queue(队列)

    队列在线程编程中特别有用,当信息必须在多个线程之间安全交换时。

    有三种不同的用法

    class queue.Queue(maxsize=0) #队列:先进先出

    import queue
    
    q=queue.Queue()
    q.put('first')
    q.put('second')
    q.put('third')
    
    print(q.get())
    print(q.get())
    print(q.get())
    
    
    
    '''
    结果(先进先出):
    first
    second
    third
    '''
    

     

    class queue.LifoQueue(maxsize=0) #堆栈:last in fisrt out

    import queue
    
    q=queue.LifoQueue()
    q.put('first')
    q.put('second')
    q.put('third')
    
    print(q.get())
    print(q.get())
    print(q.get())
    
    
    
    '''
    结果(后进先出):
    third
    second
    first
    '''
    

      

    class queue.PriorityQueue(maxsize=0) #优先级队列:存储数据时可设置优先级的队列

    import queue
    
    q=queue.PriorityQueue()
    #put进入一个元组,元组的第一个元素是优先级(通常是数字,也可以是非数字之间的比较),数字越小优先级越高
    q.put((20,'a'))
    q.put((10,'b'))
    q.put((30,'c'))
    
    print(q.get())
    print(q.get())
    print(q.get())
    
    
    
    '''
    结果(数字越小优先级越高,优先级高的优先出队):
    (10, 'b')
    (20, 'a')
    (30, 'c')
    '''
    

      

     

  • 相关阅读:
    git线上操作
    IDEA快捷方式
    Java 四种线程池
    java 获取当前天之后或之前7天日期
    如何理解AWS 网络,如何创建一个多层安全网络架构
    申请 Let's Encrypt 通配符 HTTPS 证书
    GCE 部署 ELK 7.1可视化分析 nginx
    使用 bash 脚本把 AWS EC2 数据备份到 S3
    使用 bash 脚本把 GCE 的数据备份到 GCS
    nginx 配置 https 并强制跳转(lnmp一键安装包)
  • 原文地址:https://www.cnblogs.com/zzhhtt/p/9012541.html
Copyright © 2011-2022 走看看