如何：使用柵欄同步並行操作
下列範例示範如何使並行任務與 Barrier同步。
範例
下列程式的目的是計算兩個線程需要多少次迭代（或階段），才能在同一階段中，各自找到其解答的一半，這是透過隨機化演算法重新洗牌單字來達成的。 在每個執行緒洗牌其單字之後，屏障後的階段性操作會比較這兩個結果，以查看完整句子是否以正確的字順序排列。
//#define TRACE
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
namespace BarrierSimple
{
class Program
{
static string[] words1 = new string[] { "brown", "jumps", "the", "fox", "quick"};
static string[] words2 = new string[] { "dog", "lazy","the","over"};
static string solution = "the quick brown fox jumps over the lazy dog.";
static bool success = false;
static Barrier barrier = new Barrier(2, (b) =>
{
StringBuilder sb = new StringBuilder();
for (int i = 0; i < words1.Length; i++)
{
sb.Append(words1[i]);
sb.Append(" ");
}
for (int i = 0; i < words2.Length; i++)
{
sb.Append(words2[i]);
if(i < words2.Length - 1)
sb.Append(" ");
}
sb.Append(".");
#if TRACE
System.Diagnostics.Trace.WriteLine(sb.ToString());
#endif
Console.CursorLeft = 0;
Console.Write("Current phase: {0}", barrier.CurrentPhaseNumber);
if (String.CompareOrdinal(solution, sb.ToString()) == 0)
{
success = true;
Console.WriteLine($"\r\nThe solution was found in {barrier.CurrentPhaseNumber} attempts");
}
});
static void Main(string[] args)
{
Thread t1 = new Thread(() => Solve(words1));
Thread t2 = new Thread(() => Solve(words2));
t1.Start();
t2.Start();
// Keep the console window open.
Console.ReadLine();
}
// Use Knuth-Fisher-Yates shuffle to randomly reorder each array.
// For simplicity, we require that both wordArrays be solved in the same phase.
// Success of right or left side only is not stored and does not count.
static void Solve(string[] wordArray)
{
while(success == false)
{
Random random = new Random();
for (int i = wordArray.Length - 1; i > 0; i--)
{
int swapIndex = random.Next(i + 1);
string temp = wordArray[i];
wordArray[i] = wordArray[swapIndex];
wordArray[swapIndex] = temp;
}
// We need to stop here to examine results
// of all thread activity. This is done in the post-phase
// delegate that is defined in the Barrier constructor.
barrier.SignalAndWait();
}
}
}
}
Imports System.Collections.Generic
Imports System.Linq
Imports System.Text
Imports System.Threading
Imports System.Threading.Tasks
Class Program
Shared words1() = New String() {"brown", "jumps", "the", "fox", "quick"}
Shared words2() = New String() {"dog", "lazy", "the", "over"}
Shared solution = "the quick brown fox jumps over the lazy dog."
Shared success = False
Shared barrier = New Barrier(2, Sub(b)
Dim sb = New StringBuilder()
For i As Integer = 0 To words1.Length - 1
sb.Append(words1(i))
sb.Append(" ")
Next
For i As Integer = 0 To words2.Length - 1
sb.Append(words2(i))
If (i < words2.Length - 1) Then
sb.Append(" ")
End If
Next
sb.Append(".")
System.Diagnostics.Trace.WriteLine(sb.ToString())
Console.CursorLeft = 0
Console.Write("Current phase: {0}", barrier.CurrentPhaseNumber)
If (String.CompareOrdinal(solution, sb.ToString()) = 0) Then
success = True
Console.WriteLine()
Console.WriteLine("The solution was found in {0} attempts", barrier.CurrentPhaseNumber)
End If
End Sub)
Shared Sub Main()
Dim t1 = New Thread(Sub() Solve(words1))
Dim t2 = New Thread(Sub() Solve(words2))
t1.Start()
t2.Start()
' Keep the console window open.
Console.ReadLine()
End Sub
' Use Knuth-Fisher-Yates shuffle to randomly reorder each array.
' For simplicity, we require that both wordArrays be solved in the same phase.
' Success of right or left side only is not stored and does not count.
Shared Sub Solve(ByVal wordArray As String())
While success = False
Dim rand = New Random()
For i As Integer = 0 To wordArray.Length - 1
Dim swapIndex As Integer = rand.Next(i + 1)
Dim temp As String = wordArray(i)
wordArray(i) = wordArray(swapIndex)
wordArray(swapIndex) = temp
Next
' We need to stop here to examine results
' of all thread activity. This is done in the post-phase
' delegate that is defined in the Barrier constructor.
barrier.SignalAndWait()
End While
End Sub
End Class
Barrier 是一個物件，可防止平行作業中的個別工作繼續執行，直到所有工作到達屏障為止。 當平行作業在階段中發生，而且每個階段都需要工作之間的同步處理時，這非常有用。 在此範例中，作業有兩個階段。 在第一個階段中，每個工作都會以數據填滿緩衝區的區段。 當每個工作完成填滿其區段時，工作會向屏障發出信號，表示已準備好繼續，然後等候。 當所有工作都發出屏障信號時，它們就會解除封鎖，而第二個階段就會開始。 屏障是必要的，因為第二個階段要求每個工作都能夠存取已產生至此點的所有數據。 如果沒有障礙，首要完成的任務可能會嘗試從其他任務尚未填入的緩衝區中讀取。 您可以以此方式同步任意數量的階段。
另請參閱
- 平行程序設計 數據結構
