如何判断线程池中线程是否全部执行完成

线程全部执行完了，但是 if (workerThreads == maxWordThreads) 这个判断怎么也不成立，
判断方法是 当线程池的可用线程数 == 线程池最大线程数时 为子线程全部执行完成，
大家帮我看看问题出在哪儿了
using Microsoft.VisualStudio.TestTools.UnitTesting;

using System.Collections.Generic;
using System.Threading;
namespace Ex.Tester.Threads
{
    [TestClass]
    public class ThreadPoolTester
    {
        /// <summary>
        /// 
        /// </summary>
        [TestMethod]
        public void TestCheckThreadPoolStatus()
        {
            //启动多线程
            ThreadPoolTest.RunWork();
            //检查线程是否执行完成
            List<string> successList = null;
            int len = 0;
            do
            {
                successList = ThreadPoolTest.SuccessList;
                len = successList == null ? 0 : successList.Count;
                Thread.Sleep(1000);
            } while (!ThreadPoolTest.IsFinish);
        }
        class ThreadPoolTest
        {
            private static object m_lock = new object();
            private static object m_lock_check = new object();
            public static List<string> SuccessList = new List<string>();
            private static string msg = "";
            public static bool IsFinish = false;
            /// <summary>
            /// 每秒检次一次线程池的状态 
            /// </summary>
            static RegisteredWaitHandle m_Rhw = ThreadPool.RegisterWaitForSingleObject(
                new AutoResetEvent(false),
                new WaitOrTimerCallback(CheckThreadPool),
                null,
                1000,
                false);
            public static void CheckThreadPool(object state, bool timeout)
            {
                lock (m_lock_check)
                {
                    int workerThreads = 0; //可用辅助线程的数目。
                    int maxWordThreads = 0; //线程池中辅助线程的最大数目。
                    int completionPortThreads = 0; //线程池中异步 I/O 线程的最大数目。
                    ThreadPool.GetAvailableThreads(out workerThreads, out completionPortThreads);
                    ThreadPool.GetMaxThreads(out maxWordThreads, out completionPortThreads);
                    //当可用的线数与池程池最大的线程相等时表示线程池中所有的线程已经完成  
                    if (workerThreads == maxWordThreads)
                    {
                        //当执行此方法后CheckThreadPool将不再执行  
                        m_Rhw.Unregister(null);
                        IsFinish = true;
                    }
                }
            }

            private static void DoWork(object par)
            {
                lock (m_lock)
                {
                    SuccessList.Add(par.ToString());
                }
            }
            public static void RunWork()
            {
                ThreadPool.SetMaxThreads(10, 5);
                for (int i = 0; i < 20; i++)
                {
                    int workerThreads = 0;
                    int completionPortThreads = 0; //线程池中异步 I/O 线程的最大数目。
                    ThreadPool.GetAvailableThreads(out workerThreads, out completionPortThreads);
                    ThreadPool.QueueUserWorkItem(new WaitCallback(DoWork), "T" + i.ToString()+",r="+workerThreads+",c="+completionPortThreads);
                }
            }
        }
    }
}
---- 40分

List<Func<MyResultType>> arr;
........
var ehs = new List<ManualResetEvent>();
var results = new List<MyResultType>();
foreach (var t in arr)
{
    var m = new ManualResetEvent(false);
    ehs.Add(m);
    ThreadPool.QueueUserWorkItem(h =>
    {
        results.Add(t());
        m.Set();
    });
}
foreach (var m in ehs)
    m.WaitOne();
//继续向后执行

var results = (from t in arr.AsParallel() select t()).ToList();

public void methodAsync(Action<MyResultType> callback)
{
    ........在当前线程处理数据准备
  ThreadPool.QueueUserWorkItem(h =>
    {
        在其它线程执行其它耗时、可并发的数据操作
        MyResultType result =  .........
        callback(result);
    });
}

using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
namespace Ex.RulesTester.Threads
{
    /// <summary>
    /// 异步等待所有线程结束通知测试
    /// </summary>
    [TestClass]
    public class TaskAllCompleteTester
    {
        [TestMethod]
        public void TestTaskPoolStatus()
        {
            //运行异步多任务
            TaskTest.RunTask();
            var list = TaskTest.SuccessList;
            bool isAllComplete = false;
            //等待异步通知
            while (!isAllComplete)
            {
                isAllComplete = TaskTest.IsAllComplete;
                list = TaskTest.SuccessList;
            }

            Assert.IsTrue(true);
        }
        /// <summary>
        /// 对于 task 多任务执行的封装
        /// </summary>
        private class TaskTest
        {
            private static object m_lock = new object();
            public static List<string> SuccessList = new List<string>();
            private static string msg = "";
            public static bool IsFinish = false;
            public static List<Task> TaskList = new List<Task>();
            static bool isAllComplete = false;
            /// <summary>
            /// 标记所有任务是否全部执行完毕
            /// </summary>
            public static bool IsAllComplete
            {
                get { return isAllComplete; }
            }
            private TaskTest()
            {
            }

            public static void RunTask()
            {
                //运行5个任务
                for (int i = 1; i <= 5; i++)
                {
                    var task = Task.Factory.StartNew(DoTask, i);
                    TaskList.Add(task);
                }
                //异步等待所有任务执行完毕
                Task.Factory.StartNew(x =>
                {
                    Task.WaitAll(TaskList.ToArray());
                    //标记所有任务运行完成
                    isAllComplete = true;
                }, null);
            }
            private static void DoTask(object par)
            {
                Thread.Sleep(int.Parse(par.ToString()) * 1000);
                lock (m_lock)
                {
                    SuccessList.Add("Has Completed T" + par.ToString());
                }
            }

        }
    }
}