Python多线程-Barrier(障碍对象)

Barrier(parties, action=None, timeout=None)

每个线程通过调用wait()尝试通过障碍，并阻塞，直到阻塞的数量达到parties时，阻塞的线程被同时全部释放。

action是一个可调用对象，当线程被释放时，其中一个线程会首先调用action，之后再跑自己的代码。

timeout时默认的超时时间。

方法：

wait(timeout=None)

尝试通过障碍并阻塞。

返回值是一个在0到parties-1范围内的整数，每个线程都不同。

其中一个线程在释放之前将调用action。如果此调用引发错误，则障碍将进入断开状态。

如果等待超时，障碍也将进入断开状态。

如果在线程等待期间障碍断开或重置，此方法可能会引发BrokenBarrierError错误。

reset()

重置障碍，返回默认的空状态，即当前阻塞的线程重新来过。见例二

abort()

将障碍置为断开状态，这将导致已调用wait()或之后调用wait()引发BrokenBarrierError。见例三

属性：

partier

通过障碍所需的线程数。

n_waiting

当前在屏障中等待的线程数

broken

如果屏障处于断开状态，则返回True。

实例

例一：

# -*- coding:utf-8 -*-
import threading
import time

def open():
    print('人数够了， 开门!')

barrier = threading.Barrier(3, open)

class Customer(threading.Thread):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.n = 3

    def run(self):
        while self.n > 0:
            self.n -= 1
            print('{0}在等着开门.'.format(self.name))
            try:
                barrier.wait(2)
            except threading.BrokenBarrierError:
                pass
            print('开门了， go go go')

if __name__ == '__main__':
    t1 = Customer(name='A')
    t2 = Customer(name='B')
    t3 = Customer(name='C')
    t1.start()
    t2.start()
    t3.start()

运行结果：

A在等着开门.
B在等着开门.
C在等着开门.
人数够了， 开门!
开门了， go go go
开门了， go go go
开门了， go go go
C在等着开门.
A在等着开门.
B在等着开门.
人数够了， 开门!
开门了， go go go
开门了， go go go
开门了， go go go
...

例二：

# -*- coding:utf-8 -*-
import threading
import time

def open():
    print('人数够了， 开门!')

barrier = threading.Barrier(3, open)

class Customer(threading.Thread):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.n = 3

    def run(self):
        while self.n > 0:
            self.n -= 1
            print('{0}在等着开门.'.format(self.name))
            try:
                barrier.wait(2)
            except threading.BrokenBarrierError:
                continue
            print('开门了， go go go')

class Manager(threading.Thread):
    def run(self):
        print('前面几个排队的不算，重新来')
        barrier.reset()

if __name__ == '__main__':
    t1 = Customer(name='A')
    t2 = Customer(name='B')
    t3 = Customer(name='C')
    tm = Manager()
    t1.start()
    t2.start()
    tm.start()
    t3.start()

运行结果：

A在等着开门.
B在等着开门.
前面几个排队的不算，重新来
A在等着开门.
B在等着开门.
C在等着开门.
人数够了， 开门!
开门了， go go go
开门了， go go go
开门了， go go go
A在等着开门.
C在等着开门.
B在等着开门.
人数够了， 开门!
开门了， go go go
开门了， go go go
开门了， go go go
C在等着开门.

例三：

# -*- coding:utf-8 -*-
import threading

def open():
    print('人数够了， 开门!')

barrier = threading.Barrier(3, open)

class Customer(threading.Thread):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.n = 3

    def run(self):
        while self.n > 0:
            self.n -= 1
            print('{0}在等着开门.'.format(self.name))
            try:
                barrier.wait(2)
            except threading.BrokenBarrierError:
                print('今天好像不开门了，回家.')
                break
            print('开门了， go go go')

class Manager(threading.Thread):
    def run(self):
        print('老板跟小姨子跑了，不开门了！')
        barrier.reset()

if __name__ == '__main__':
    t1 = Customer(name='A')
    t2 = Customer(name='B')
    t3 = Customer(name='C')
    tm = Manager()
    t1.start()
    t2.start()
    tm.start()
    t3.start()

运行结果：

A在等着开门.
B在等着开门.
老板跟小姨子跑了，不开门了！
今天好像不开门了，回家.
今天好像不开门了，回家.
C在等着开门.
今天好像不开门了，回家.