这是一种安全的方式来执行线程吗？

Question

我想交替运行代码，所以我可以在任何时候停止执行。这段代码安全吗？

static class Program 
{ 
    static void Main() 
    { 
     var foo = new Foo(); 
     //wait for interaction (this will be GUI app, so eg. btnNext_click) 
     foo.Continue(); 
     //wait again etc. 
     foo.Continue(); 
     foo.Continue(); 
     foo.Continue(); 
     foo.Continue(); 
     foo.Continue(); 
    } 
} 

class Foo 
{ 
    public Foo() 
    { 
     new Thread(Run).Start(); 
    } 

    private void Run() 
    { 
     Break(); 
     OnRun(); 
    } 

    protected virtual void OnRun() 
    { 
     for (var i = 0; i < 5; i++) 
     { 
      Console.WriteLine(i); 
      Break(); 
     } 
     //do something else and break; 
    } 

    private void Break() 
    { 
     lock (this) 
     { 
      Monitor.Pulse(this); 
      Monitor.Wait(this); 
     } 
    } 

    public void Continue() 
    { 
     lock (this) 
     { 
      Monitor.Pulse(this); 
      Monitor.Wait(this); 
     } 
    } 
} 

当然我知道，现在应用程序永远不会结束，但那不是重点。

我需要这个，因为我想介绍某种算法的步骤，并描述在特定时刻发生了什么，并且在一个线程中做出所有事情会导致很多并发症，即使使用少量循环代码。例如那些行：

for (var i = 0; i < 5; i++) 
{ 
    Console.WriteLine(i); 
    Break(); 
} 

应该与再换成：

if (this.i < 5) 
{ 
    Console.WriteLine(i++); 
} 

这是我想提出什么只是一个小例子。代码将比虚拟for循环更复杂。

Answer 1

我建议你看看这个blog post关于实施纤维。

代码（如果网站出现故障。）

public class Fiber 
{ 
    private readonly Stack<IEnumerator> stackFrame = new Stack<IEnumerator>(); 
    private IEnumerator currentRoutine; 

    public Fiber(IEnumerator entryPoint) 
    { 
     this.currentRoutine = entryPoint; 
    } 

    public bool Step() 
    { 
     if (currentRoutine.MoveNext()) 
     { 
      var subRoutine = currentRoutine.Current 
          as IEnumerator; 
      if (subRoutine != null) 
      { 
       stackFrame.Push(currentRoutine); 
       currentRoutine = subRoutine; 
      } 
     } 
     else if (stackFrame.Count > 0) 
     { 
      currentRoutine = stackFrame.Pop(); 
     } 
     else 
     { 
      OnFiberTerminated(
       new FiberTerminatedEventArgs(
        currentRoutine.Current 
      ) 
     ); 
      return false; 
     } 

     return true; 
    } 

    public event EventHandler<FiberTerminatedEventArgs> FiberTerminated; 

    private void OnFiberTerminated(FiberTerminatedEventArgs e) 
    { 
     var handler = FiberTerminated; 
     if (handler != null) 
     { 
      handler(this, e); 
     } 
    } 
} 

public class FiberTerminatedEventArgs : EventArgs 
{ 
    private readonly object result; 

    public FiberTerminatedEventArgs(object result) 
    { 
     this.result = result; 
    } 

    public object Result 
    { 
     get { return this.result; } 
    } 
} 

class FiberTest 
{ 
    private static IEnumerator Recurse(int n) 
    { 
     Console.WriteLine(n); 
     yield return n; 
     if (n > 0) 
     { 
      yield return Recurse(n - 1); 
     } 
    } 

    static void Main(string[] args) 
    { 
     var fiber = new Fiber(Recurse(5)); 
     while (fiber.Step()) ; 
    } 
} 

Answer 2

“......这将是GUI应用程序......”

那么你可能不希望，不会有连续的代码像上面Main()。

I.e.主GUI线程不会执行上述的串行代码，但通常是空闲的，重新绘制等或处理按钮单击。
在该事件处理程序中，您最好使用Auto|ManualResetEvent来指示工作人员继续。
在工人，只是等待事件。

Answer 3

我会建议任何时候一个考虑使用Monitor.Wait()，应该写代码，以便它如果Wait有时正常工作自发地行动，好像它收到了一个脉冲。通常，这意味着应该使用模式：

lock(monitorObj) 
{ 
    while(notYetReady) 
    Monitor.Wait(monitorObj); 
} 

对于您的情况，我建议做这样的事情：

lock(monitorObj) 
{ 
    turn = [[identifier for this "thread"]]; 
    Monitor.PulseAll(monitorObj); 
    while(turn != [[identifier for this "thread"]]) 
    Monitor.Wait(monitorObj); 
} 

这是不可能的turn其之间的变化是检查它是否是当前线程继续进行并且Monitor.Wait。因此，如果Wait未被跳过，则PulseAll被保证唤醒它。请注意，如果Wait自发地起作用，就好像它收到了一个脉冲一样，代码就可以正常工作 - 它只会旋转，观察turn未设置为当前线程，并返回等待状态。