0

以下是我使用的代码。主线程等待线程池线程执行。我使用 AutoResetEvent (WaitHandle)，但我真的很惊讶我偏离了标准，因为代码没有按预期运行。

我有两个同心的 for 循环，其中 Threadpool 位于内部循环中，并且预计对于外部循环的每次迭代，都应处理所有内部循环值。使用 AutoResetEvent WaitOne 在内部循环外部调用使主线程等待，这是一个静态变量，在外部循环的每次迭代中重置为内部循环的最大值，并在使用 Threadpool 线程的方法调用中使用 Interlock 递减为 AutoResetEvent 调用 Set。但是，即使我希望静态变量在每个内部循环之后显示值 0，它也不会。我的代码有什么问题，我有什么更好的选择来完成任务？事实上，由于值的混淆，主线程似乎并没有真正等待线程池线程。

using System;
using System.Threading;

namespace TestThreads
{
class Program
{
    private static int threadingCounter = 0;
    private static readonly object lockThreads = new Object();
    private AutoResetEvent areSync = new AutoResetEvent(true);

    // <param name="args"></param>
    static void Main(string[] args)
    {
        Program myProgram = new Program();

        try
        {
            try
            {   
                for (int outer = 0; outer < 1000; outer++)
                {
                    threadingCounter = 500;
                    try
                    {
                        for (int inner = 0; inner < 500; inner++)
                        {
                            ThreadPool.QueueUserWorkItem(new
                                 WaitCallback(myProgram.ThreadCall), inner);
                        }
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine("Exception :: " + ex.Message);
                    }
                    finally
                    {                            
                        myProgram.areSync.WaitOne();
                    }

                    if(threadingCounter != 0)
                        Console.WriteLine("In Loop1, Thread Counter :: " +
                            threadingCounter);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("Exception :: " + ex.Message);
            }                
        }
        catch(Exception ex)
        {
            Console.WriteLine("Exception :: " + ex.Message);
        }
        finally
        {
            threadingCounter = 0;

            if (myProgram.areSync != null)
            {
                myProgram.areSync.Dispose();
                myProgram.areSync = null;
            }
        }
    }

    public void ThreadCall(object state)
    {
        try
        {
            int inner = (int)state;
            Thread.Sleep(1);
        }
        catch (Exception ex)
        {
            Console.WriteLine("Exception :: " + ex.Message);
        }
        finally
        {
            Interlocked.Decrement(ref threadingCounter);
            if (threadingCounter <= 0)
                areSync.Set();
        }                
    }        
 }
}
4

2 回答 2

2

您已初始化 AutoResetEvent，初始状态为 signaled(true)，这将允许首次调用

myProgram.areSync.WaitOne();

继续没有阻塞，所以它继续外循环和队列再次执行到线程池，因此结果搞砸了。很清楚。

将您的代码更新为

private AutoResetEvent areSync = new AutoResetEvent(false);

为预期的结果。希望这可以帮助

于 2013-07-12T20:00:05.083 回答
0

我会用这样的东西重构它。这假设您想在内部循环的后台线程中执行某些操作，在继续执行下一个外部循环之前完成每个线程，避免混乱的异常处理，同时仍捕获处理期间发生的异常，以便您可以在处理后处理这些异常内循环和外循环都是完整的。

// track exceptions that occurred in loops
class ErrorInfo
{
    public Exception Error { get; set; }
    public int Outer { get; set; }
    public int Inner { get; set; }
}

class Program
{
    static void Main(string[] args)
    {
        // something to store execeptions from inner thread loop
        var errors = new ConcurrentBag<ErrorInfo>();
        // no need to wrap a try around this simple loop
        // unless you want an exception to stop the loop
        for (int outer = 0; outer < 10; outer++)
        {
            var tasks = new Task[50];
            for (int inner = 0; inner < 50; inner++)
            {
                var outerLocal = outer;
                var innerLocal = inner;
                tasks[inner] = Task.Factory.StartNew(() =>
                    {
                        try
                        {
                            Thread.Sleep(innerLocal);
                            if (innerLocal % 5 == 0)
                            {
                                throw new Exception("Test of " + innerLocal);
                            }
                        }
                        catch (Exception e)
                        {
                            errors.Add(new ErrorInfo
                            {
                                Error = e,
                                Inner = innerLocal,
                                Outer = outerLocal
                            });
                        }
                    });
            }
            Task.WaitAll(tasks);
        }
        Console.WriteLine("Error bag contains {0} errors.", errors.Count);
        Console.ReadLine();
    }
}
于 2013-07-21T18:40:47.663 回答