并行计算延迟

Question

我正在使用parallel.for在多个线程中启动外部程序。但尽管事实上这些是单独的线程，我需要实现诸如延迟之类的东西。例如，2 个线程想要同时启动此外部程序 - 那么其中一个线程应该等待并在第二个线程后 10 秒启动。

是否可以？

Answer 1

这是可能的，但考虑到您提供的信息，这似乎毫无意义......您正在强制外部程序的单线程执行，因此您也可能有一个线程执行它。如果线程 2 必须等待线程 1 才能启动“外部程序”，那么就让线程 1 完成此后的所有工作它已经知道它何时启动“外部程序”。

从多线程方法中获得的唯一好处是，如果在执行“外部程序”之前需要执行大量处理，并且该处理必须是并发执行的良好候选者。

更新

好的，有几种方法可以只用一个额外的线程来完成此操作，以保持主/GUI 线程的响应能力。第一种方法是围绕您正在交互的外部资源进行简单的锁定：

public class ExternalResourceHandler
{
    private readonly ExternalResource _resource;
    private readonly object _sync = new object();

    // constructors
    // ...
    // other methods

    public void PerformExternalOperation()
    { 
        lock(_sync)
        {

            Result result = _resource.Execute();

            // do soemthing with the result
        }
    }
}

这里有 3 个用于执行代码的多线程版本：

1. 使用 Parallel.For 方法：如果外部程序需要，则推荐使用执行时间很短——我建议执行时间在 25 秒以内（尽管这不一定是“正确”的数字）。
2. 使用ThreadPool：再次，我建议您执行少于 25 秒的操作（与上面的保留相同）。
3. 使用Thread：如果操作运行时间较长（即超过 25 秒，但如果运行时间低于 25 秒，效果同样好），则建议使用该方法。

以下是一些示例（不一定是功能性的，主要是为了让您了解不同的方法）：

public class Program
{
    public static ExternalResourceHandler _erh = new ExternalResourceHandler();

    static int Main()
    {
        Console.WriteLine("Type 'exit' to stop; 'parallel', 'pool' or 'thread' for the corresponding execution version.");
        string input = Console.ReadLine();
        while(input != "exit")
        {
            switch(input)
            {
            case "parallel":
                // Run the Parallel.For version
                ParallelForVersion();
                break;
            caase "pool":
                // Run the threadpool version
                ThreadPoolVersion();
                break;
            case "thread":
                // Run the thread version
                ThreadVersion();
                break;
            default:
                break;
            }
            input = Console.ReadLine();
        }
        return 0;
    }

    public static void ParallelForVersion()
    {
        Parallel.For(0, 1, i =>
        {
            _erh.PerformExternalOperation();
        });
    }

    public static void ThreadPoolVersion()
    {
        ThreadPool.QueueUserWorkItem(o=>
        {
            _erh.PerformExternalOperation();
        });
    }

    public static void ThreadVersion()
    {
        Thread t = new Thread(()=>
        {
            _erh.PerformExternalOperation();
        });
        t.IsBackground = true;
        t.Start();

    }
}

另一种选择是采用生产者/消费者设计模式，其中您的 ExternalResourceHandler 是消费者并进行处理从线程安全队列向外部资源发出请求。您的主线程只是将请求放入队列并立即返回工作。这是一个示例：

public class ExternalResourceHandler
{
    private volatile boolean _running;
    private readonly ExternalResource _resource;
    private readonly BlockingQueue<Request> _requestQueue;

    public ExternalResourceHandler( BlockingQueue<Request> requestQueue)
    {
        _requestQueue =  requestQueue;
        _running = false;
    }

    public void QueueRequest(Request request)
    { 
        _requestQueue.Enqueue(request);
    }

    public void Run()
    {
        _running = true;
        while(_running)
        {
            Request request = null;
            if(_requestQueue.TryDequeue(ref request) && request!=null)
            {
                _resource.Execute(request);
            }
        }
    }

    // methods to stop the handler (i.e. set the _running flag to false)
}

您的主线程将如下所示：

public class Program
{
    public static ExternalResourceHandler _erh = new ExternalResourceHandler();

    static int Main()
    {   
        Thread erhThread = new Thread(()=>{_erh.Run();});
        erhThread.IsBackground = true;
        erhThread.Start();

        Console.WriteLine("Type 'exit' to stop or press enter to enqueue another request.");
        string input = Console.ReadLine();
        while(input != "exit")
        {
            _erh.EnqeueRequest(new Request());
            input = Console.ReadLine();
        }

        // Stops the erh by setting the running flag to false
        _erh.Stop();

        // You may also need to interrupt the thread in order to
        // get it out of a blocking state prior to calling Join()
        erhThread.Join();
        return 0;
    }
}

如您所见：在这两种情况下，外部处理程序的所有工作都强制在单个线程上进行，但您的主线程仍然保持响应。

Answer 2

看看生产者-消费者模式。第一个线程产生“外部程序已启动”信息，第二个线程使用该信息，等待 10 秒，然后启动外部程序。