共用方式為

Barrier 類別

  • 參考

定義

命名空間:
System.Threading
組件:
System.Threading.dll
組件:
System.dll
組件:
netstandard.dll

允許多項工作在多個階段中以平行方式來合作處理某個演算法。

public ref class Barrier : IDisposable
public class Barrier : IDisposable
[System.Runtime.InteropServices.ComVisible(false)]
public class Barrier : IDisposable
type Barrier = class
    interface IDisposable
[<System.Runtime.InteropServices.ComVisible(false)>]
type Barrier = class
    interface IDisposable
Public Class Barrier
Implements IDisposable
繼承
Object
Barrier
屬性
ComVisibleAttribute
實作
IDisposable

範例

下列範例示範如何使用屏障：

using System;
using System.Threading;
using System.Threading.Tasks;

class BarrierDemo
{
    // Demonstrates:
    //      Barrier constructor with post-phase action
    //      Barrier.AddParticipants()
    //      Barrier.RemoveParticipant()
    //      Barrier.SignalAndWait(), incl. a BarrierPostPhaseException being thrown
    static void BarrierSample()
    {
        int count = 0;

        // Create a barrier with three participants
        // Provide a post-phase action that will print out certain information
        // And the third time through, it will throw an exception
        Barrier barrier = new Barrier(3, (b) =>
        {
            Console.WriteLine("Post-Phase action: count={0}, phase={1}", count, b.CurrentPhaseNumber);
            if (b.CurrentPhaseNumber == 2) throw new Exception("D'oh!");
        });

        // Nope -- changed my mind.  Let's make it five participants.
        barrier.AddParticipants(2);

        // Nope -- let's settle on four participants.
        barrier.RemoveParticipant();

        // This is the logic run by all participants
        Action action = () =>
        {
            Interlocked.Increment(ref count);
            barrier.SignalAndWait(); // during the post-phase action, count should be 4 and phase should be 0
            Interlocked.Increment(ref count);
            barrier.SignalAndWait(); // during the post-phase action, count should be 8 and phase should be 1

            // The third time, SignalAndWait() will throw an exception and all participants will see it
            Interlocked.Increment(ref count);
            try
            {
                barrier.SignalAndWait();
            }
            catch (BarrierPostPhaseException bppe)
            {
                Console.WriteLine("Caught BarrierPostPhaseException: {0}", bppe.Message);
            }

            // The fourth time should be hunky-dory
            Interlocked.Increment(ref count);
            barrier.SignalAndWait(); // during the post-phase action, count should be 16 and phase should be 3
        };

        // Now launch 4 parallel actions to serve as 4 participants
        Parallel.Invoke(action, action, action, action);

        // This (5 participants) would cause an exception:
        // Parallel.Invoke(action, action, action, action, action);
        //      "System.InvalidOperationException: The number of threads using the barrier
        //      exceeded the total number of registered participants."

        // It's good form to Dispose() a barrier when you're done with it.
        barrier.Dispose();
    }
}

Imports System.Threading
Imports System.Threading.Tasks

Module BarrierSample

    ' Demonstrates:
    ' Barrier constructor with post-phase action
    ' Barrier.AddParticipants()
    ' Barrier.RemoveParticipant()
    ' Barrier.SignalAndWait(), incl. a BarrierPostPhaseException being thrown
    Sub Main()
        Dim count As Integer = 0

        ' Create a barrier with three participants
        ' Provide a post-phase action that will print out certain information
        ' And the third time through, it will throw an exception
        Dim barrier As New Barrier(3,
                                   Sub(b)
                                       Console.WriteLine("Post-Phase action: count={0}, phase={1}", count, b.CurrentPhaseNumber)
                                       If b.CurrentPhaseNumber = 2 Then
                                           Throw New Exception("D'oh!")
                                       End If
                                   End Sub)

        ' Nope -- changed my mind. Let's make it five participants.
        barrier.AddParticipants(2)

        ' Nope -- let's settle on four participants.
        barrier.RemoveParticipant()


        ' This is the logic run by all participants
        Dim action As Action =
            Sub()
                Interlocked.Increment(count)
                barrier.SignalAndWait()
                ' during the post-phase action, count should be 4 and phase should be 0

                Interlocked.Increment(count)
                barrier.SignalAndWait()
                ' during the post-phase action, count should be 8 and phase should be 1

                ' The third time, SignalAndWait() will throw an exception and all participants will see it
                Interlocked.Increment(count)
                Try
                    barrier.SignalAndWait()
                Catch bppe As BarrierPostPhaseException
                    Console.WriteLine("Caught BarrierPostPhaseException: {0}", bppe.Message)
                End Try

                ' The fourth time should be hunky-dory
                Interlocked.Increment(count)
                ' during the post-phase action, count should be 16 and phase should be 3
                barrier.SignalAndWait()

            End Sub

        ' Now launch 4 parallel actions to serve as 4 participants
        Parallel.Invoke(action, action, action, action)

        ' This (5 participants) would cause an exception:
        '   Parallel.Invoke(action, action, action, action, action)
        ' "System.InvalidOperationException: The number of threads using the barrier
        ' exceeded the total number of registered participants."

        ' It's good form to Dispose() a barrier when you're done with it.
        barrier.Dispose()
    End Sub
End Module

備註

一組工作會透過一系列階段進行合作，其中群組中的每個工作都會發出其抵達 Barrier 指定階段的訊號，並隱含等候其他人抵達。 相同的 Barrier 可用於多個階段。

建構函式

Barrier(Int32)

初始化 Barrier 類別的新執行個體。
Barrier(Int32, Action<Barrier>)

初始化 Barrier 類別的新執行個體。

屬性

CurrentPhaseNumber

取得屏障目前階段的編號。
ParticipantCount

取得在屏障中的參與者總數。
ParticipantsRemaining

取得在目前階段中尚未發出訊號的屏障中參與者數目。

方法

AddParticipant()

通知 Barrier，表示還會有一個其他參與者。
AddParticipants(Int32)

通知 Barrier，表示還會有多個其他參與者。
Dispose()

釋放 Barrier 類別目前的執行個體所使用的全部資源。
Dispose(Boolean)

釋放 Barrier 所使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。
Equals(Object)

判斷指定的物件是否等於目前的物件。

(繼承來源 Object)
GetHashCode()

做為預設雜湊函式。

(繼承來源 Object)
GetType()

取得目前執行個體的 Type。

(繼承來源 Object)
MemberwiseClone()

建立目前 Object 的淺層複製。

(繼承來源 Object)
RemoveParticipant()

通知 Barrier，表示會減少一個參與者。
RemoveParticipants(Int32)

通知 Barrier，表示會減少一些參與者。
SignalAndWait()

發出訊號，表示參與者已到達屏障，並且在等候所有其他參與者到達屏障。
SignalAndWait(CancellationToken)

發出訊號，表示參與者已到達屏障，並且在等候所有其他參與者到達，同時觀察取消語彙基元。
SignalAndWait(Int32)

發出訊號，表示參與者已到達屏障，並且在等候所有其他參與者到達屏障 (使用 32 位元帶正負號的整數以測量逾時)。
SignalAndWait(Int32, CancellationToken)

發出訊號，表示參與者已到達屏障，並且在等候所有其他參與者到達 (使用 32 位元帶正負號的整數以測量逾時)，同時觀察取消語彙基元。
SignalAndWait(TimeSpan)

發出訊號，表示參與者已到達屏障，並且在等候所有其他參與者到達屏障 (使用 TimeSpan 物件以測量時間間隔)。
SignalAndWait(TimeSpan, CancellationToken)

發出訊號，表示參與者已到達屏障，並且在等候所有其他參與者到達 (使用 TimeSpan 物件以測量時間間隔)，同時觀察取消語彙基元。
ToString()

傳回代表目前物件的字串。

(繼承來源 Object)

適用於

執行緒安全性

的所有公用和受保護成員 Barrier 都是安全線程，而且可以從多個執行緒同時使用，但 Dispose 除外，這只有在 上所有其他作業 Barrier 都已完成時才使用。

另請參閱