Barrier Barrier Barrier Barrier Class

Définition

Permet à plusieurs tâches de coopérer en parallèle sur un algorithme via plusieurs phases.Enables multiple tasks to cooperatively work on an algorithm in parallel through multiple phases.

public ref class Barrier : IDisposable
[System.Runtime.InteropServices.ComVisible(false)]
public class Barrier : IDisposable
type Barrier = class
    interface IDisposable
Public Class Barrier
Implements IDisposable
Héritage
BarrierBarrierBarrierBarrier
Attributs
Implémente

Exemples

L’exemple suivant montre comment utiliser un cloisonnement:The following example shows how to use a barrier:

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

Remarques

Un groupe de tâches coopère en passant par une série de phases, où chaque dans le groupe signale qu’il a atteint Barrier le dans une phase donnée et attend implicitement que toutes les autres arrivent.A group of tasks cooperate by moving through a series of phases, where each in the group signals it has arrived at the Barrier in a given phase and implicitly waits for all others to arrive. Le même Barrier peut être utilisé pour plusieurs phases.The same Barrier can be used for multiple phases.

Constructeurs

Barrier(Int32) Barrier(Int32) Barrier(Int32) Barrier(Int32)

Initialise une nouvelle instance de la classe Barrier.Initializes a new instance of the Barrier class.

Barrier(Int32, Action<Barrier>) Barrier(Int32, Action<Barrier>) Barrier(Int32, Action<Barrier>) Barrier(Int32, Action<Barrier>)

Initialise une nouvelle instance de la classe Barrier.Initializes a new instance of the Barrier class.

Propriétés

CurrentPhaseNumber CurrentPhaseNumber CurrentPhaseNumber CurrentPhaseNumber

Obtient le numéro de la phase actuelle du cloisonnement.Gets the number of the barrier's current phase.

ParticipantCount ParticipantCount ParticipantCount ParticipantCount

Obtient le nombre total de participants au cloisonnement.Gets the total number of participants in the barrier.

ParticipantsRemaining ParticipantsRemaining ParticipantsRemaining ParticipantsRemaining

Obtient le nombre de participants au cloisonnement qui n’ont pas encore été signalés dans la phase actuelle.Gets the number of participants in the barrier that haven't yet signaled in the current phase.

Méthodes

AddParticipant() AddParticipant() AddParticipant() AddParticipant()

Signale à Barrier qu'il y aura un participant supplémentaire.Notifies the Barrier that there will be an additional participant.

AddParticipants(Int32) AddParticipants(Int32) AddParticipants(Int32) AddParticipants(Int32)

Signale à Barrier qu'il y aura des participants supplémentaires.Notifies the Barrier that there will be additional participants.

Dispose() Dispose() Dispose() Dispose()

Libère toutes les ressources utilisées par l'instance actuelle de la classe Barrier.Releases all resources used by the current instance of the Barrier class.

Dispose(Boolean) Dispose(Boolean) Dispose(Boolean) Dispose(Boolean)

Libère les ressources non managées utilisées par le Barrier, et libère éventuellement les ressources managées.Releases the unmanaged resources used by the Barrier, and optionally releases the managed resources.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Fait office de fonction de hachage par défaut.Serves as the default hash function.

(Inherited from Object)
GetType() GetType() GetType() GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crée une copie superficielle de l'objet Object actuel.Creates a shallow copy of the current Object.

(Inherited from Object)
RemoveParticipant() RemoveParticipant() RemoveParticipant() RemoveParticipant()

Signale à Barrier qu'il y aura un participant en moins.Notifies the Barrier that there will be one less participant.

RemoveParticipants(Int32) RemoveParticipants(Int32) RemoveParticipants(Int32) RemoveParticipants(Int32)

Signale à Barrier qu'il y aura moins de participants.Notifies the Barrier that there will be fewer participants.

SignalAndWait() SignalAndWait() SignalAndWait() SignalAndWait()

Signale qu'un participant a atteint le cloisonnement et qu'il attend que tous les autres participants atteignent également le cloisonnement.Signals that a participant has reached the barrier and waits for all other participants to reach the barrier as well.

SignalAndWait(CancellationToken) SignalAndWait(CancellationToken) SignalAndWait(CancellationToken) SignalAndWait(CancellationToken)

Signale qu'un participant a atteint le cloisonnement et qu'il attend que tous les autres participants atteignent également le cloisonnement, tout en observant un jeton d'annulation.Signals that a participant has reached the barrier and waits for all other participants to reach the barrier, while observing a cancellation token.

SignalAndWait(Int32) SignalAndWait(Int32) SignalAndWait(Int32) SignalAndWait(Int32)

Signale qu'un participant a atteint le cloisonnement et qu'il attend que tous les autres participants atteignent également le cloisonnement, à l'aide d'un entier signé 32 bits pour mesurer le délai d'attente.Signals that a participant has reached the barrier and waits for all other participants to reach the barrier as well, using a 32-bit signed integer to measure the timeout.

SignalAndWait(Int32, CancellationToken) SignalAndWait(Int32, CancellationToken) SignalAndWait(Int32, CancellationToken) SignalAndWait(Int32, CancellationToken)

Signale qu'un participant a atteint le cloisonnement et qu'il attend que tous les autres participants atteignent également le cloisonnement, à l'aide d'un entier signé 32 bits pour mesurer le délai d'attente, tout en observant un jeton d'annulation.Signals that a participant has reached the barrier and waits for all other participants to reach the barrier as well, using a 32-bit signed integer to measure the timeout, while observing a cancellation token.

SignalAndWait(TimeSpan) SignalAndWait(TimeSpan) SignalAndWait(TimeSpan) SignalAndWait(TimeSpan)

Signale qu'un participant a atteint le cloisonnement et qu'il attend que tous les autres participants atteignent également le cloisonnement, à l'aide d'un objet TimeSpan qui mesure l'intervalle de temps.Signals that a participant has reached the barrier and waits for all other participants to reach the barrier as well, using a TimeSpan object to measure the time interval.

SignalAndWait(TimeSpan, CancellationToken) SignalAndWait(TimeSpan, CancellationToken) SignalAndWait(TimeSpan, CancellationToken) SignalAndWait(TimeSpan, CancellationToken)

Signale qu'un participant a atteint le cloisonnement et qu'il attend que tous les autres participants atteignent également le cloisonnement, à l'aide d'un objet TimeSpan qui mesure l'intervalle de temps, tout en observant un jeton d'annulation.Signals that a participant has reached the barrier and waits for all other participants to reach the barrier as well, using a TimeSpan object to measure the time interval, while observing a cancellation token.

ToString() ToString() ToString() ToString()

Retourne une chaîne qui représente l'objet actuel.Returns a string that represents the current object.

(Inherited from Object)

S’applique à

Cohérence de thread

Tous les membres publics et protégés Barrier de sont thread-safe et peuvent être utilisés simultanément à partir de plusieurs threads, à l’exception de dispose, qui ne doit être utilisé que lorsque toutes les Barrier autres opérations sur le sont terminées.All public and protected members of Barrier are thread-safe and may be used concurrently from multiple threads, with the exception of Dispose, which must only be used when all other operations on the Barrier have completed.

Voir aussi