zoukankan      html  css  js  c++  java
  • python-线程

    Python对多线程提供了很好的支持,Python中多线程相关的模块包括:thread,threading,Queue。可以方便地支持创建线程、互斥锁、信号量、同步等特性。

    1. thread:多线程的底层支持模块,除了其中提供的 Lock 原语外,一般不建议使用。

    2. threading:基于 thread 模块,将一些线程的操作对象化,该模块提供下列类:

      Thread,线程类

      Timer,与Thread类似,但要等待一段时间后才开始运行

      Lock,锁原语,和 thread 模块提供的 Lock 相同

      RLock,可重入锁。使单线程可以再次获得已经获得的锁

      Condition,条件变量,能让一个线程停下来,等待其他线程满足某个“条件”

      Event,通用的条件变量。多个线程可以等待某个事件发生,在事件发生后,所有的线程都被激活

      Semaphore,为等待锁的线程提供一个类似“等候室”的结构

    3. Queue:实现了多生产者(Producer)、多消费者(Consumer)的队列,支持锁原语,能够在多个线程之间提供很好的同步支持。提供的类:

      Queue队列

      LifoQueue后入先出(LIFO)队列

      PriorityQueue 优先队列

     

    Thread in Python

    1.1 Thread对象的创建

      通过实例化Thread类型获得一个Thread对象:

    1
    threading.Thread(name=None, target=None, args=(), kwargs={})

      参数的含义:

    •   name:新线程的名称,如果没有指定,python会为其生成一个随机的唯一名称;
    •   target:新线程中将要执行的函数;t.run() 会调用 target(*args, **kwargs)
    •   args和kwargs:这是传递给线程中运行的主函数 target 的参数,当线程开始运行时,将会以这些参数调用执行主函数 target()。

    1.2 Thread对象的方法

    1
    t.getName()

      返回线程当前的名字。

    1
    t.setName(name)

      设置线程的名字,线程的名称并不要求唯一。

    1
    t.isAlive()

      判断这个线程是否还在运行中(active)——已经调用了start() 而 run() 还没有执行结束。

    1
    t.isDaemon()

      判断线程是不是一个daemon线程,初始状态下,线程 t1 只有在创建自己的线程 t0 是daemon时,自己才是daemon的。

    1
    t.setDaemon(daemonic)

      把线程的daemon标志设为daemonic(真或假)

      daemon 线程是指,即使这个线程 t 的状态是 active,Python也可以终止 t(可能是通过终止 t 所在的进程);非daemon线程没有终止前,Python会一直保持运行直到其终止。

      setDaemon()需要在start()之前调用。

    1
    t.join(timeout=None)

      这个函数需要注意,比如在一个线程 t1 的执行流程中调用 t2.join(),则 t1 阻塞直到 t2 线程执行结束,如果指定 timeout,则 t1 最多阻塞timeout秒,否则 t1 将一直等下去。

      join()只能在start()之后调用;

    1
    t.run()

      线程通过 run() 调用传入的主函数 target,不要直接调用run(),而是调用start()函数,start()函数会调用run()。

    1
    t.start()

      开始线程执行

    Python线程运行的流程

     1. 创建一个线程 t= threading.Thread(),此时新创建的线程并不会立即执行;

     2. 如果想要将 t 设置为守护线程,在调用 t.start() 之前调用 t.setDaemon(True);否则忽略本步;

     3. 调用 t.start(),此时线程开始执行,状态更新为 active。更具体的,start() 会进一步调用 run() 函数,run() 函数再去调用创建线程对象时传入的主函数 target,从而让线程有了执行的具体内容;

     4. 当线程中的主函数执行完成或遇到未处理的异常时,线程终止执行;daemon线程也可能因为所在进程终止而被Python终止。

    Python线程同步机制

     threading 模块提供的线程同步原语包括:Lock、RLock、Condition、Event、Semaphore等对象。

    1. Lock

    1.1 Lock对象的创建

      Lock是Python中最底层的同步机制,直接由底层模块 thread 实现,每个lock对象只有两种状态——上锁和未上锁,不同于下文的RLock对象,Lock对象是不可重入的,也没有所属的线程这个概念。

      可以通过下面两种方式创建一个Lock对象,新创建的 Lock 对象处于未上锁的状态:

    1
    2
    thread.allocate_lock()
    threading.Lock()

      但他们本质上都是在 thread 模块中实现的。

    例如:

    1
    2
    3
    4
    5
    >>> l = threading.Lock()
    >>> type(l)
    <type 'thread.lock'>
    >>> l
    <thread.lock object at 0x0000000001C8F190>

    1.2 lock对象的方法

      lock对象提供三种方法:acquire()、locked()和release()

    1
    l.acquire(wait=True)

      该函数需要结合参数 wait 进行讨论:

      1. 当 wait 是 False 时,如果 l 没有上锁,那么acquire()调用将l上锁,然后返回True;

      2. 当 wait 是 False 时,如果 l 已经上锁,那么acquire()调用对 l 没有影响,然后返回False;

      3. 当 wait 是 True 时,如果 l 没有上锁,acquire()调用将其上锁,然后返回True;

      4. 当 wait 是 True 时,如果 l 已经上锁,此时调用 l.acquire() 的线程将会阻塞,直到其他线程调用 l.release(),这里需要注意的是,就算这个线程是最后一个锁住 l 的线程,只要它以wait=True调用了acquire(),那它就会阻塞,因为Lock原语是不支持重入的。

      可将,只要 l 没有上锁,调用 acquire()的结果是相同的。当l 上锁了,而 wait=False 时,线程会立即得到一个返回值,不会阻塞在等待锁上面;而 wait = True时,线程会阻塞等待其他的线程释放该锁,所以,一个锁上面可能有多个处于阻塞等待状态的线程。

    1
    l.locked()

      判断 l 当前是否上锁,如果上锁,返回True,否则返回False。

    1
    l.release()

      解开 l 上的锁,要求:

    • 任何线程都可以解开一个已经锁上的Lock对象;
    • l 此时必须处于上锁的状态,如果试图 release() 一个 unlocked 的锁,将抛出异常 thread.error。

      l一旦通过release()解开,之前等待它(调用过 l.acquire())的所有线程中,只有一个会被立即被唤醒,然后获得这个锁。

    2. RLock 可重入锁

    2.1 RLock对象的创建

      RLock是可重入锁,提供和lock对象相同的方法,可重入锁的特点是

    •   记录锁住自己的线程 t ,这样 t 可以多次调用 acquire() 方法而不会被阻塞,比如 t 可以多次声明自己对某个资源的需求。
    •   可重入锁必须由锁住自己的线程释放(rl.release())
    •   rlock内部有一个计数器,只有锁住自己的线程 t 调用的 release() 方法和之前调用 acquire() 方法的次数相同时,才会真正解锁一个rlock。

      通过:

    1
    >>> rl = threading.RLock()

      可以创建一个可重入锁。

    2.2 rlock对象的方法

      rlock()对象提供和Lock对象相同的acquire()和release()方法。

    3. Condition 条件变量

    3.1 Condition 对象的获取

      condition对象封装了一个lock或rlock对象,通过实例化Condition类来获得一个condition对象:

    1
    = threading.Condition(lock=None)

      正如前面说的,condition对象的是基于Lock对象RLock对象的,如果创建 condition 对象时没传入 lock 对象,则会新创建一个RLock对象。

    3.2 Condition 对象的方法

      Condition对象封装在一个Lock或RLock对象之上,提供的方法有:acquire(wait=1)、release()、notify()、notifyAll()和wait(timeout=None)

    1
    c.acquire(wait=1)<br>c.release()

      本质上, condition对象的 acquire() 方法和 release() 方法都是底层锁对象的对应方法,在调用condition对象的其他方法之前,都应该确保线程已经拿到了condition对象对应的锁,也就是调用过 acquire()。

    1
    2
    c.notify()
    c.notify_all()

      notify()唤醒一个等待 c 的线程,notify_all() 则会唤醒所有等待 c 的线程;

      线程在调用 notify() 和 notifyAll() 之前必须已经获得 c 对应的锁,否则抛出 RuntimeError。

      notify() 和 notifyAll() 并不会导致线程释放锁,但是notify() 和 notify_all()之后,唤醒了其他的等待线程,当前线程已经准备释放锁,因此线程通常会紧接着调用 release() 释放锁。

    1
    c.wait(timeout=None)

      wait()最大的特点是调用wait()的线程必须已经acquire()了 c ,调用wait()将会使这个线程放弃 c,线程在此阻塞,然后当wait()返回时,这个线程往往又拿到了 c 。这个描述比较绕,看一个直观一点的:

      一个线程想要对临界资源进行操作,首先要获得 c ,获得 c 后,它判断临界资源的状态对不对,发现不对,就调用 wait()放掉手中的 c ,这时候实际上就是在等其他的线程来更新临界资源的状态了。当某个其他的线程修改了临界资源的状态,然后唤醒等待 c 的线程,这时我们这个线程又拿到 c (假设很幸运地抢到了),就可以继续执行了。

      如果临界资源一直不对,而我们这个线程又抢到了 c ,就可以通过一个循环,不断地释放掉不需要的锁,直到临界资源的状态符合我们的要求。

    例如:

     
    # 消费者
    cv.acquire()
    while not an_item_is_available():
        cv.wait()
    get_an_available_item()
    cv.release()
     
    # 生产者
    cv.acquire()
    make_an_item_available()
    cv.notify()
    cv.release()

      这个例子中,消费者在产品没有被生产出来之前,就算拿到 c ,也会立即调用 wait() 释放,当产品被生产出来后,生产者唤醒一个消费者,消费者重新回到 wait() 阻塞的地方,发现产品已经就绪,于是消费产品,最后释放 c 。

    4 Event 事件

    4.1 Event 对象的创建

      Event对象可以让任何数量的线程暂停和等待,event 对象对应一个 True 或 False 的状态(flag),刚创建的event对象的状态为False。通过实例化Event类来获得一个event对象:

    1
    = threading.Event()

      刚创建的event对象 e,它的状态为 False。

    4.2 Event 对象的方法

    1
    e.clear()

      将 e 的状态设置为 False。

    1
    e.set()

      将 e 的状态设置为 True。

      此时所有等待 e 的线程都被唤醒进入就绪状态。

    1
    e.is_set()

      返回 e 的 状态——True 或 False。

    1
    e.wait(timeout=None)

      如果 e 的状态为True,wait()立即返回True,否则线程会阻塞直到超时或者其他的线程调用了e.set()。

    5. Semaphore 信号量

    5.1 Semaphore 对象的创建

      信号量无疑是线程同步中最常用的技术了,信号量是一类通用的锁,锁的状态通常就是真或假,但是信号量有一个初始值,这个值往往反映了固定的资源量。

      通过调用:

    1
    = threading.Semaphore(n=1)

      创建一个Python信号量对象,参数 指定了信号量的初值。

    5.2 Semaphore对象的方法

    1
    s.acquire(wait=True)
    • 当 s 的值 > 0 时,acquire() 会将它的值减 1,同时返回 True。
    • 当 s 的值 = 0 时,需要根据参数 wait 的值进行判断:如果wait为True,acquire() 会阻塞调用它的线程,直到有其他的线程调用 release() 为止;如果wait为False,acquire() 会立即返回False,告诉调用自己的线程,当前没有可用的资源。
    1
    s.release()
    • 当 s 的值 > 0 时,release()会直接将 s 的值加一;
    • 当 s 的值 = 0 时而当前没有其他等待的线程时,release() 也会将 s 的值加一;
    • 当 s 的值 = 0 时而当前其他等待的线程时,release() 不改变 s 的值(还是0),唤醒任意一个等待信号量的线程;调用release()的线程继续正常执行。

    Queue模块

    Queue模块支持先进先出(FIFO)队列,支持多线程的访问,包括一个主要的类型(Queue)和两个异常类(exception classes)。

      Python 2 中的Queue模块在Python 3中更名为 queue。

    Queue对象的创建

      可以通过实例化Queue类型获得队列对象:

    1
    = Queue.Queue(maxsize=0)

      创建新的队列,参数 maxsize 的含义是:

    • 如果 maxsize > 0:当 q 中的元素达到 maxsize 个时,队列就满了,此时再有一个线程希望向里面插入时,如果指定了 block 选项,就会阻塞直到一个线程从里面抽出一个元素。
    • 如果 maxsize <= 0:Python会认为这是一个没有容量限制的队列。

    Queue模块定义的异常类

    1
    Queue.Empty

      如果队列 q 是空的,此时又调用了 q.get(False),就会抛出该异常。

    1
    Queue.Full

      如果队列q是满的,而又调用了 q.put(x, False),就会抛出该异常。

    Queue对象的方法

    q.empty()

       判断队列是否为空。

    q.full()

       判断队列是否已满。

    q.get(block=True, timeout=None)
    q.get_nowait()

      参数 block 为 False 时,参数 timeout 没有意义,因为线程不会阻塞:

    • 如果队列不为空,取走并返回该元素;
    • 如果队列为空,抛出Queue.Empty

      block 为 True 时,结合超时 timeout 判断当队列空时,是一直阻塞进程,还是进程阻塞一段时间。

      get_nowait()等于get(False),或者get(timeout=0)即不论队列空否,都不阻塞等待。

    例如:

     
    try:
        = q.get_nowait()
    except Queue.Empty:
        print "no more items to process"
    q.put(item, block=True, timeout=None)
    q.put_nowait(item)

      向队列中插入 item,如果队列满了,抛出Queue.Full或线程阻塞等待。

    q.qsize()

      返回当前队列中的元素个数。

    q.join()
    q.task_done()
  • 相关阅读:
    Ubuntu 11.04 安装后要做的20件事情
    Net 服务命令行参考之一
    Openerp约束句型
    Ubuntu进入Shell
    postgreSql基础命令及linux下postgreSql命令
    解决中文乱码的问题
    An error occured while handling a json request
    Java Socket编程
    CentOS 7 中 Docker 的安装和卸载
    Spring Boot整合shiro-登录认证和权限管理
  • 原文地址:https://www.cnblogs.com/muzinan110/p/4966921.html
Copyright © 2011-2022 走看看