Barrier Classe

Riferimento

Definizione

Spazio dei nomi:: System.Threading

Assembly:: System.Threading.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Consente a più attività di funzionare in modo cooperativo in un algoritmo in parallelo tramite più fasi.

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

Ereditarietà: Object
Barrier

Attributi: ComVisibleAttribute

Implementazioni: IDisposable

Esempio

Nell'esempio seguente viene illustrato come usare una barriera:

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

Commenti

Un gruppo di attività collabora passando attraverso una serie di fasi, dove ognuno dei segnali del gruppo è arrivato in Barrier una determinata fase e attende implicitamente che tutti gli altri arrivino. Lo stesso Barrier può essere usato per più fasi.

Costruttori

Barrier(Int32)	Inizializza una nuova istanza della classe Barrier.
Barrier(Int32, Action<Barrier>)	Inizializza una nuova istanza della classe Barrier.

Proprietà

CurrentPhaseNumber	Ottiene il numero di fase corrente della barriera.
ParticipantCount	Ottiene il numero totale di partecipanti nella barriera.
ParticipantsRemaining	Ottiene il numero di partecipanti nella barriera che non hanno ancora eseguito la segnalazione nella fase corrente.

Metodi

AddParticipant()	Notifica all'oggetto Barrier che sarà presente un partecipante aggiuntivo.
AddParticipants(Int32)	Notifica all'oggetto Barrier che saranno presenti partecipanti aggiuntivi.
Dispose()	Rilascia tutte le risorse usate dall'istanza corrente della classe Barrier.
Dispose(Boolean)	Rilascia le risorse non gestite usate dall'oggetto Barrier e, facoltativamente, le risorse gestite.
Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetType()	Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object)
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
RemoveParticipant()	Notifica all'oggetto Barrier che sarà presente un partecipante in meno.
RemoveParticipants(Int32)	Notifica all'oggetto Barrier che saranno presenti meno partecipanti.
SignalAndWait()	Segnala che un partecipante ha raggiunto la barriera e attende che venga raggiunta anche da tutti gli altri partecipanti.
SignalAndWait(CancellationToken)	Segnala che un partecipante ha raggiunto la barriera e attende che venga raggiunta anche da tutti gli altri partecipanti, al contempo osservando un token di annullamento.
SignalAndWait(Int32)	Segnala che un partecipante ha raggiunto la barriera e attende che venga raggiunta anche da tutti gli altri partecipanti, utilizzando un Signed Integer a 32 bit per misurare il timeout.
SignalAndWait(Int32, CancellationToken)	Segnala che un partecipante ha raggiunto la barriera e attende che venga raggiunta anche da tutti gli altri partecipanti, utilizzando un Signed Integer a 32 bit per misurare il timeout, al contempo osservando un token di annullamento.
SignalAndWait(TimeSpan)	Segnala che un partecipante ha raggiunto la barriera e attende che venga raggiunta anche da tutti gli altri partecipanti, utilizzando un oggetto TimeSpan per misurare l'intervallo di tempo.
SignalAndWait(TimeSpan, CancellationToken)	Segnala che un partecipante ha raggiunto la barriera e attende che venga raggiunta anche da tutti gli altri partecipanti, utilizzando un oggetto TimeSpan per misurare l'intervallo di tempo, al contempo osservando un token di annullamento.
ToString()	Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)

Si applica a

Thread safety

Tutti i membri pubblici e protetti di sono thread-safe e possono essere usati simultaneamente da più thread, con l'eccezione di Barrier Dispose, che deve essere usato solo quando tutte le altre operazioni sull'oggetto Barrier sono state completate.