Ansible相当于Puppet的“除非”属性(Ansible equivalent of Puppet's “unless” attribute)

 在这里你应该记住几件事： 
 
 
 
 它存在一个Thread.Suspend机制， 这里描述但它已经过时，并且有充分的理由，因为： 
 
 
 
 
 因为Thread.Suspend和Thread.Resume不依赖于被控制的线程的协作，所以它们是高度侵入性的并且可能导致严重的应用程序问题，例如死锁（例如，如果你挂起一个拥有另一个线程的资源的线程需要）。 
 
 
 因此，您可以使用该机制并等待并查看可能的死锁或其他同步错误或： 
 
 
 
 您可以将该同步逻辑移动到要挂起的线程中，在您的情况下使用processRunning()方法并执行以下操作： 
 while（i <execTime.Sum（）&& flag == 0）//尚未停止 
 
 
 如果你想要更精细的粒度，甚至在循环的中间停止而不是在每次迭代时，你可以随意添加更多的检查。 
 
 您还需要将标志声明为volatile，因为该字段由两个线程使用，需要标记为： 
 
 public static volatile int flag = 0 ; 
 
 这是一个简化的例子： 
 
    private static AutoResetEvent signal = new AutoResetEvent(false);
    private volatile static bool interruptFlag;
    private volatile static bool abortFlag;

    private static void Process()
    {
        //replace true with your condition
        while (true)
        {
            if (interruptFlag)
            {
                if (signal.WaitOne())
                {
                    if (abortFlag)
                    {
                        Console.WriteLine("exiting");
                        return;
                    }
                }
            }

            Console.WriteLine("doing work");

            //.. important work here
        } 
    }

    private static void Interrupt() {
        ConsoleKeyInfo c = Console.ReadKey();
        if (c.Key == ConsoleKey.Enter) {
            interruptFlag = true;
            // Should Pause The First Thread Here And Ask To Continue/Resume Or Kill

            c = Console.ReadKey();

            if (c.Key == ConsoleKey.Escape)
            {
                Console.WriteLine("Interrupting");
                abortFlag = true;
                signal.Set();
            }
            else
            {
                Console.WriteLine("Continuing");
                interruptFlag = false;
                abortFlag = false;
                signal.Set();
            }
        }
    }

    static void Main()
    {
        Thread process = new Thread(Process);
        process.Start();

        Thread interrupt = new Thread(Interrupt);
        interrupt.Start();

    }

There are a couple of things that you should have in mind here:
 
 
 
It exists a Thread.Suspend mechanism described here but it is obsolete and for a good reason, since:
 
 
 
 
Because Thread.Suspend and Thread.Resume do not rely on the cooperation of the thread being controlled, they are highly intrusive and can result in serious application problems like deadlocks (for example, if you suspend a thread that holds a resource that another thread will need).
 
 
So you could use that mechanism and wait and see possible deadlocks or other synchronization bugs or:
 
 
 
You could move that synchronization logic into the thread that you want to suspend, the processRunning() method in your case and do something like this:
 
while (i < execTime.Sum() && flag==0) //not stopped yet
 
 
If you want finer granularity, that is even stopping in the middle of the loop not at each iteration, it is your job to add more checks as you please.
 
You also need to declare your flag as volatile since that field is used by two threads and needs to be marked as such:
 
public static volatile int flag = 0;
 
This is a simplified example:
 
    private static AutoResetEvent signal = new AutoResetEvent(false);
    private volatile static bool interruptFlag;
    private volatile static bool abortFlag;

    private static void Process()
    {
        //replace true with your condition
        while (true)
        {
            if (interruptFlag)
            {
                if (signal.WaitOne())
                {
                    if (abortFlag)
                    {
                        Console.WriteLine("exiting");
                        return;
                    }
                }
            }

            Console.WriteLine("doing work");

            //.. important work here
        } 
    }

    private static void Interrupt() {
        ConsoleKeyInfo c = Console.ReadKey();
        if (c.Key == ConsoleKey.Enter) {
            interruptFlag = true;
            // Should Pause The First Thread Here And Ask To Continue/Resume Or Kill

            c = Console.ReadKey();

            if (c.Key == ConsoleKey.Escape)
            {
                Console.WriteLine("Interrupting");
                abortFlag = true;
                signal.Set();
            }
            else
            {
                Console.WriteLine("Continuing");
                interruptFlag = false;
                abortFlag = false;
                signal.Set();
            }
        }
    }

    static void Main()
    {
        Thread process = new Thread(Process);
        process.Start();

        Thread interrupt = new Thread(Interrupt);
        interrupt.Start();

    }