BarrieraBarrier

Una classe System.Threading.Barrier è una primitiva di sincronizzazione definita dall'utente che permette a più thread (noti come partecipanti) di lavorare contemporaneamente su un algoritmo in fasi diverse.A System.Threading.Barrier is a synchronization primitive that enables multiple threads (known as participants) to work concurrently on an algorithm in phases. Ogni partecipante viene eseguito fino al raggiungimento del punto barriera nel codice.Each participant executes until it reaches the barrier point in the code. La barriera rappresenta la fine di una fase di lavoro.The barrier represents the end of one phase of work. Quando un partecipante raggiunge la barriera, si blocca fino al raggiungimento della stessa barriera da parte di tutti i partecipanti.When a participant reaches the barrier, it blocks until all participants have reached the same barrier. Dopo che tutti i partecipanti hanno raggiunto la barriera, è possibile richiamare facoltativamente un'azione post- fase.After all participants have reached the barrier, you can optionally invoke a post-phase action. Questa azione post- fase può essere usata per eseguire azioni da parte di un singolo thread mentre tutti gli altri thread rimangono bloccati.This post-phase action can be used to perform actions by a single thread while all other threads are still blocked. Dopo l'esecuzione dell'azione, tutti i partecipanti verranno sbloccati.After the action has been executed, the participants are all unblocked.

Il frammento di codice seguente mostra un modello di barriera di base.The following code snippet shows a basic barrier pattern.


 // Create the Barrier object, and supply a post-phase delegate 
 // to be invoked at the end of each phase.
 Barrier barrier = new Barrier(2, (bar) => 
     {
         // Examine results from all threads, determine 
         // whether to continue, create inputs for next phase, etc. 
         if (someCondition)
             success = true;
     });       
 
     
 // Define the work that each thread will perform. (Threads do not
 // have to all execute the same method.)
 void CrunchNumbers(int partitionNum)
 {
     // Up to System.Int64.MaxValue phases are supported. We assume
     // in this code that the problem will be solved before that.
     while (success == false)
     {
         // Begin phase:
         // Process data here on each thread, and optionally
         // store results, for example:
         results[partitionNum] = ProcessData(data[partitionNum]);

         // End phase:
         // After all threads arrive,post-phase delegate
         // is invoked, then threads are unblocked. Overloads
         // accept a timeout value and/or CancellationToken.
         barrier.SignalAndWait();
     }
 }

 // Perform n tasks to run in in parallel. For simplicity
// all threads execute the same method in this example.
 static void Main()
 {
     var app = new BarrierDemo();
     Thread t1 = new Thread(() => app.CrunchNumbers(0));
     Thread t2 = new Thread(() => app.CrunchNumbers(1));
     t1.Start();
     t2.Start();
     
 }

' Create the Barrier object, and supply a post-phase delegate 
' to be invoked at the end of each phase.
Dim barrier = New Barrier(2, Sub(bar)
                                 ' Examine results from all threads, determine 
                                 ' whether to continue, create inputs for next phase, etc. 
                                 If (someCondition) Then
                                     success = True
                                 End If
                             End Sub)



' Define the work that each thread will perform. (Threads do not
' have to all execute the same method.)
Sub CrunchNumbers(ByVal partitionNum As Integer)

    ' Up to System.Int64.MaxValue phases are supported. We assume
    ' in this code that the problem will be solved before that.
    While (success = False)

        ' Begin phase:
        ' Process data here on each thread, and optionally
        ' store results, for example:
        results(partitionNum) = ProcessData(myData(partitionNum))

        ' End phase:
        ' After all threads arrive,post-phase delegate
        ' is invoked, then threads are unblocked. Overloads
        ' accept a timeout value and/or CancellationToken.
        barrier.SignalAndWait()
    End While
End Sub

' Perform n tasks to run in in parallel. For simplicity
' all threads execute the same method in this example.
Shared Sub Main()

    Dim app = New BarrierDemo()
    Dim t1 = New Thread(Sub() app.CrunchNumbers(0))
    Dim t2 = New Thread(Sub() app.CrunchNumbers(1))
    t1.Start()
    t2.Start()
End Sub

Per un esempio completo, vedere Procedura: Sincronizzare operazioni simultanee con una barriera.For a complete example, see How to: synchronize concurrent operations with a Barrier.

Aggiunta e rimozione di partecipantiAdding and removing participants

Quando si crea un'istanza di Barrier, specificare il numero di partecipanti.When you create a Barrier instance, specify the number of participants. È anche possibile aggiungere o rimuovere dinamicamente i partecipanti in qualsiasi momento.You can also add or remove participants dynamically at any time. Se ad esempio un partecipante risolve la propria parte di problema, sarà possibile archiviare il risultato, arrestare l'esecuzione in quel thread e chiamare Barrier.RemoveParticipant per ridurre il numero di partecipanti nella barriera.For example, if one participant solves its part of the problem, you can store the result, stop execution on that thread, and call Barrier.RemoveParticipant to decrement the number of participants in the barrier. Quando si aggiunge un partecipante chiamando Barrier.AddParticipant, il valore restituito specifica il numero di fase attuale, che potrebbe essere utile per inizializzare il lavoro del nuovo partecipante.When you add a participant by calling Barrier.AddParticipant, the return value specifies the current phase number, which may be useful in order to initialize the work of the new participant.

Barriere interrotteBroken barriers

Se un partecipante non riesce a raggiungere la barriera, possono verificarsi deadlock.Deadlocks can occur if one participant fails to reach the barrier. Per evitare questi deadlock, usare gli overload del metodo Barrier.SignalAndWait per specificare un periodo di timeout e un token di annullamento.To avoid these deadlocks, use the overloads of the Barrier.SignalAndWait method to specify a time-out period and a cancellation token. Questi overload restituiscono un valore booleano che ogni partecipante può controllare prima di passare alla fase successiva.These overloads return a Boolean value that every participant can check before it continues to the next phase.

Eccezioni di post-fasePost-phase exceptions

Se il delegato post-fase genera un'eccezione, ne verrà eseguito il wrapping in un oggetto BarrierPostPhaseException, che viene quindi propagato a tutti i partecipanti.If the post-phase delegate throws an exception, it is wrapped in a BarrierPostPhaseException object which is then propagated to all participants.

Confronto tra barriera e ContinueWhenAllBarrier versus ContinueWhenAll

Le barriere risultano particolarmente utili quando i thread eseguono più fasi nei cicli.Barriers are especially useful when the threads are performing multiple phases in loops. Se il codice richiede solo una o due fasi di lavoro, prendere in considerazione l'uso di oggetti System.Threading.Tasks.Task con qualsiasi tipo di join implicito, inclusi i seguenti:If your code requires only one or two phases of work, consider whether to use System.Threading.Tasks.Task objects with any kind of implicit join, including:

Per altre informazioni, vedere Concatenamento di attività tramite attività di continuazione.For more information, see Chaining Tasks by Using Continuation Tasks.

Vedere ancheSee also