Python中的屏障对象-yiteyi-C++库

python中的Barrier对象用于等待固定数量的线程完成执行，然后任何特定线程才能继续执行程序。每个线程在到达屏障时调用wait（）函数。屏障负责跟踪wait（）调用的数量。如果这个数字超过了为其初始化屏障的线程数，那么屏障会让等待的线程继续执行。此时执行的所有线程都会同时释放。

null

屏障甚至可以用来同步线程之间的访问。然而，通常使用屏障来组合线程的输出。barrier对象可以重复使用多次，重复使用的线程数与初始初始化的线程数完全相同。

初始化屏障

可以使用线程初始化屏障。屏障等级如以下程序所示。括号内的数字表示屏障应等待的线程数。

语法：

barrier = threading.Barrier(number_of_threads, action = None, timeout = None)

为线程数创建一个屏障对象。如果提供了一个操作，则该操作是一个可调用的操作，可在其中一个线程被释放时被调用。如果wait（）方法没有指定超时值，则timeout是默认超时值。

                     import                               threading                   
                             
                     barrier                               =                               threading.Barrier(                               3                               )                   
                             
                     class                               thread(threading.Thread):                   
                                         def                               __init__(                               self                               , thread_ID):                   
                                         threading.Thread.__init__(                               self                               )                   
                                         self                               .thread_ID                               =                               thread_ID                   
                                         def                               run(                               self                               ):                   
                                         print                               (                               str                               (                               self                               .thread_ID)                               +                               ""                               )                   
                                         barrier.wait()                   
                             
                     thread1                               =                               thread(                               100                               )                   
                     thread2                               =                               thread(                               101                               )                   
                             
                     thread1.start()                   
                     thread2.start()                   
                     barrier.wait()                   
                             
                     print                               (                               "Exit"                               )                   

输出：

100
101
Exit

与线程相关的一些常见函数调用。障碍等级为：

检查安全栅的状态： 断开：如果屏障处于断开状态，则布尔值为真。 语法：
```
barrier.broken
```
聚会：通过屏障所需的螺纹数。 语法：
```
barrier.parties
```
取消障碍： 中止：将屏障置于断开状态。这会导致任何活动或未来的调用wait（）失败，并出现BrokenBarrierError
在程序执行期间，通常需要对barrier进行中止函数调用，以跳过死锁的条件。 语法：
```
barrier.abort()
```
重置屏障： 重置：将屏障恢复为默认的空状态。等待它的所有线程都将收到BrokenBarrierError异常。
语法：
```
barrier.reset()
```
等待：通过障碍物。当所有参与屏障的线程调用此函数时，它们将同时释放。如果提供了超时，则它将优先于提供给类构造函数的任何超时。
返回值是0到1之间的整数，每个线程的返回值不同。如果呼叫超时，屏障将进入断开状态。如果在线程等待时屏障被破坏或重置，此方法可能会引发BrokenBarrierError异常。

语法：
```
barrier.wait(timeout = None)
```
n_等待 ：当前在屏障中等待的线程数。 语法：
```
barrier.n_waiting
```

通常，当屏障对象被重置或损坏时，会引发BrokenBarrierError异常。

下面是一个示例程序，演示如何在python中使用屏障

                     # program to demonstrate                   
                     # barriers in python                   
                             
                     import                               threading                   
                             
                     barrier                               =                               threading.Barrier(                               3                               )                   
                             
                     class                               thread(threading.Thread):                   
                                         def                               __init__(                               self                               , thread_ID):                   
                                         threading.Thread.__init__(                               self                               )                   
                                         self                               .thread_ID                               =                               thread_ID                   
                                         def                               run(                               self                               ):                   
                                         print                               (                               str                               (                               self                               .thread_ID)                               +                               ""                               )                   
                                         print                               (                               "Parties = "                               +                               str                               (barrier.parties)                               +                               ""                               )                   
                                         print                               (                               "n_waiting = "                               +                               str                               (barrier.n_waiting)                               +                               ""                               )                   
                                         barrier.wait()                   
                             
                     thread1                               =                               thread(                               100                               )                   
                     thread2                               =                               thread(                               101                               )                   
                             
                     thread1.start()                   
                     thread2.start()                   
                             
                     barrier.wait()                   
                             
                     print                               (                               str                               (barrier.broken)                               +                               ""                               )                   
                     barrier.reset()                   
                     print                               (                               "n_waiting after reset = "                               +                               str                               (barrier.n_waiting))                   
                     barrier.abort()                   
                     print                               (                               "End"                               )                   

输出：

100
101
Parties = 3
Parties = 3
n_waiting = 1
n_waiting = 1
False
n_waiting after reset = 0
End

本文由 马扬克·库马尔 .如果你喜欢GeekSforgek，并想贡献自己的力量，你也可以使用贡献极客。组织或者把你的文章寄到contribute@geeksforgeeks.org.看到你的文章出现在Geeksforgeks主页上，并帮助其他极客。

如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写下评论。

文章版权归作者所有，未经允许请勿转载。

THE END

Python