忙于等待线程

Question

基本上，我需要忙着等到一些 html 出现在网页上。我创建了以下代码来忙着等我：

public void ExecuteBusyWaitThreads()
    {

        foreach (Canidate canidate in allCanidates)
        {
            Thread newThread = new Thread(delegate()
            {
                BusyWait(canidate);
            });

            newThread.Start();
        }
    }

    public bool BusyWait(Canidate canidate)
    {
        //hit that url, and wait for the claim all button to appear
        string page = null;
        while (found == false)
        {
            HttpWebRequest request = Canidate.GetHTTPRequest(canidate.URL);
            //make sure we add the authentication cookes to the request
            request = Canidate.AddCookiesToRequest(request, canidate.GetCookies());
            page = new Canidate().GetPage(request);
            if (page.ToLower().Contains("claim all"))
            {
                found = true;
                NotifyAllThreads();
            }
        }
        return true;
    }

所以，如果我有 8 个canidates，它将产生 8 个线程，每个线程都在寻找出现在网页上的 claim all。 found 是一个全局变量。一旦其中一个线程找到claim all，它们都应该保释。

我对这种方法有几个问题。首先，它是一个很好的方法。其次，每个线程会得到它自己的忙等待函数的“副本”。我的意思是，一个线程可以抢占另一个线程并更改该函数中的数据，还是每个线程都获得函数内部声明的变量的副本。请注意，这两个函数都在同一个对象内。

Answer 1

在我回答你的问题之前，我必须指出你犯下了closing over the loop variable的恶劣行为。

首先，这是一个很好的方法。

不，不是真的。随意创建线程通常不是一个好主意。最好使用线程池技术。这可以通过ThreadPool.QueueUserWorkItem 或Task 类来完成。

其次，每个线程会得到它自己的忙等待函数的“副本”。 我的意思是，一个线程可以抢占另一个线程并更改其中的数据吗？ 该函数，或者他们每个人都获得声明的变量的副本 在函数内部。

BusyWait 的每个运行实例都将获得所有局部变量的自己的副本（即page 和request）。由于found 是在非本地范围内声明的（大概无论如何），因此它将在BusyWait 的所有运行实例之间共享。因此，您当前对found 的读取和写入不是线程安全的，因为没有同步机制。

Answer 2

其次，每个线程是否会得到自己的忙等待函数“副本”

每个线程都将使用自己的堆栈空间执行函数，这意味着函数内部的任何本地变量都将属于它正在运行的线程。如果你有一个全局变量，比如你的 found 变量在函数内部被改变，你需要设置一个同步机制，这样多个线程就不会同时访问它，因为这会导致很难找到错误还有很多你永远不想想象的恐怖经历！

Answer 3

所有线程都有自己的局部变量副本（在这种情况下只有string page）。

您的共享 found 变量应声明为 volatile

这是一种罕见的情况，调用Thread.Sleep() 可能会有所帮助。在对同一站点的调用之间插入一点喘息。

Answer 4

每个线程都使用自己的变量副本运行。

但是我会修改我的 appoarch。使用找到的变量不是线程安全的。一次可能会发现不止一个线程正在更改。也很有可能一个线程正在读取它，而另一个线程正在写入它。 [lock][1] 可以避免这种情况。

解决此问题的更好方法是使用EventWaitHandle。这样你就不必担心锁定，你可以建立一个睡眠或超时，所以如果没有出现'claim-all'，你的线程不会运行比你希望的更长的时间。

internal class ExampleOnExecute
{
    private static EventWaitHandle _stopEvent;

    public static EventWaitHandle StopEvent
    {
        get { return _stopEvent ?? (_stopEvent = new EventWaitHandle(false, EventResetMode.ManualReset)); }
    }

    public static void SpinOffThreads(IEnumerable<object> someCollection)
    {
        foreach(var item in someCollection)
        {
            // You probably do not want to manualy create a thread since these ideally would be small workers
            // and action BeingInvoke runs in the ThreadPool
            Action<object> process = BusyWait;

            process.BeginInvoke(item, null, null);
        }
    }

    private static void BusyWait(object obj)
    {
        // You can wait for however long you like or 0 is not waiting at all
        const int sleepAmount = 1;

        //     Blocks the current thread until the current instance receives a signal, using
        //     a System.TimeSpan to specify the time interval.
        //
        // Parameters:
        //   timeout:
        //     A System.TimeSpan that represents the number of milliseconds to wait, or
        //     a System.TimeSpan that represents -1 milliseconds to wait indefinitely.
        //
        // Returns:
        //     true if the current instance receives a signal; otherwise, false.
        while (!StopEvent.WaitOne(TimeSpan.FromMilliseconds(sleepAmount)))
        {
            // Do you work here
            var foundIt = DidIFindIt();

            if (foundIt)
            {
                // Signal all threads now to stop working we found it.
                StopEvent.Set();
            }
        }
    }

    private static bool DidIFindIt()
    {
        return true;
    }
}

Here 是一本关于threading 的优秀免费书。