Barrier Clase

Referencia

Definición

Espacio de nombres:: System.Threading

Ensamblado:: System.Threading.dll

Ensamblado:: System.dll

Ensamblado:: netstandard.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Habilita varias tareas para que colaboren en un algoritmo en paralelo en varias fases.

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

Herencia: Object
Barrier

Atributos: ComVisibleAttribute

Implementaciones: IDisposable

Ejemplos

En el ejemplo siguiente se muestra cómo usar una barrera:

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

Comentarios

Un grupo de tareas coopera pasando por una serie de fases, donde cada uno de los grupos señala que ha llegado a en Barrier una fase determinada y espera implícitamente a que todos los demás lleguen. Lo mismo Barrier se puede usar para varias fases.

Constructores

Barrier(Int32)	Inicializa una nueva instancia de la clase Barrier.
Barrier(Int32, Action<Barrier>)	Inicializa una nueva instancia de la clase Barrier.

Propiedades

CurrentPhaseNumber	Obtiene el número de la fase actual de la barrera.
ParticipantCount	Obtiene el número total de participantes de la barrera.
ParticipantsRemaining	Obtiene el número de participantes en la barrera que aún no se han señalado en la fase actual.

Métodos

AddParticipant()	Notifica a Barrier que va a haber un participante adicional.
AddParticipants(Int32)	Notifica a Barrier que va a haber participantes adicionales.
Dispose()	Libera todos los recursos usados por la instancia actual de la clase Barrier.
Dispose(Boolean)	Libera los recursos no administrados utilizados por el objeto Barrier y, de forma opcional, libera los recursos administrados.
Equals(Object)	Determina si el objeto especificado es igual que el objeto actual. (Heredado de Object)
GetHashCode()	Sirve como la función hash predeterminada. (Heredado de Object)
GetType()	Obtiene el Type de la instancia actual. (Heredado de Object)
MemberwiseClone()	Crea una copia superficial del Object actual. (Heredado de Object)
RemoveParticipant()	Notifica a Barrier que va a haber un participante menos.
RemoveParticipants(Int32)	Notifica a Barrier que va a haber menos participantes.
SignalAndWait()	Señala que un participante ha alcanzado la barrera y espera a que todos los demás participantes alcancen también la barrera.
SignalAndWait(CancellationToken)	Señala que un participante ha alcanzado la barrera y espera a que todos los demás participantes alcancen la barrera mientras se observa un token de cancelación.
SignalAndWait(Int32)	Señala que un participante ha alcanzado la barrera y espera a que todos los demás participantes alcancen también la barrera usando un entero de 32 bits con signo para medir el tiempo de espera.
SignalAndWait(Int32, CancellationToken)	Señala que un participante ha alcanzado la barrera y espera a que todos los demás participantes la alcancen también usando un entero de 32 bits con signo para medir el tiempo de espera mientras se observa un token de cancelación.
SignalAndWait(TimeSpan)	Señala que un participante ha alcanzado la barrera y espera a que todos los demás participantes alcancen también la barrera usando un objeto TimeSpan para medir el intervalo de tiempo.
SignalAndWait(TimeSpan, CancellationToken)	Señala que un participante ha alcanzado la barrera y espera a que todos los demás participantes la alcancen también usando un objeto TimeSpan para medir el intervalo de tiempo, mientras se observa un token de cancelación.
ToString()	Devuelve una cadena que representa el objeto actual. (Heredado de Object)

Se aplica a

Seguridad para subprocesos

Todos los miembros públicos y protegidos de Barrier son seguros para subprocesos y se pueden usar simultáneamente desde varios subprocesos, a excepción de Dispose, que solo se deben usar cuando se hayan completado todas las demás operaciones de .Barrier