ThreadPool的代码帮助

创建了一个实现ThreadPool的类。代码如下:

PyeThreadPool:

  IDisposable
{
    private readonly object _lock = new object();
    private readonly int _minThreadCount;
    private readonly int _maxThreadCount;
    private readonly Queue<Action> _queue = new Queue<Action>();
    private int _totalThreadCount;
    private int _waitingThreadCount;
    private bool _disposed;
    public PyeThreadPool(int minThreadCount, int maxThreadCount)
    {
        if (minThreadCount < 0)
            throw new ArgumentOutOfRangeException("minThreadCount");
        if (maxThreadCount < 1 || maxThreadCount < minThreadCount)
            throw new ArgumentOutOfRangeException("maxThreadCount");
        _minThreadCount = minThreadCount;
        _maxThreadCount = maxThreadCount;

    }
    public void Dispose()
    {
        lock (_lock)
        {
            _disposed = true;
            // if there are thread waiting, they should stop waiting.
            if (_waitingThreadCount > 0)
                Monitor.PulseAll(_lock);
        }
    }
    /// <summary>
    /// Executes an action in a parallel thread. 
    /// </summary>
    public void RunParallel(Action action)
    {

            if (action == null)
                throw new ArgumentNullException("action");
            lock (_lock)
            {
                if (_disposed)
                    throw new ObjectDisposedException(GetType().FullName);
                bool queued = false;
                if (_waitingThreadCount == 0)
                {
                    if (_totalThreadCount < _maxThreadCount)
                    {
                        _totalThreadCount++;
                        var thread = new Thread(_ThreadRun);
                        thread.Name = "Worker Thread";
                        thread.Start(action);
                        queued = true;
                    }
                }
                if (!queued)
                {
                    _queue.Enqueue(action);
                    Monitor.Pulse(_lock);
                }
            }
    }
    private void _ThreadRun(object firstAction)
    {
        Action action = (Action)firstAction;
        firstAction = null;
        // we always start a new thread with an action, so we get it immediately.
        // but, as we don't know what that action really holds in memory, we set
        // the initial action to null, so after it finishes and a new action is get,
        // we will let the GC collect it.
        while (true)
        {
            action();
            lock (_lock)
            {
                if (_queue.Count == 0)
                {
                    // we started waiting, so new threads don't need to be created.
                    _waitingThreadCount++;

                    while (_queue.Count == 0)
                    {
                        if (_disposed)
                            return;

                        if (_totalThreadCount > _minThreadCount)
                        {
                            _totalThreadCount--;
                            _waitingThreadCount--;
                            return;
                        }

                        action = null;
                        Monitor.Wait(_lock);
                    }
                    // we finished waiting.
                    _waitingThreadCount--;
                }
                action = _queue.Dequeue();
                // we just get a new action, and we will release the lock and return
                // to the while, where the action will be executed.
            }
        }
    }
}

我试过使用这个，测试代码如下:

    PyeThreadPool MyPool;
    int x = 1;
    protected void Page_Load(object sender, EventArgs e)
    {
        MyPool = new PyeThreadPool(4, 6);
    }
    void showMessage(string message)
    {
        TxtMessage.Text = message;
    }

    protected void BtnStartThread_Click(object sender, EventArgs e)
    {
        x++;
        int arg = x;
        MyPool.RunParallel(() =>
        {
            showMessage(arg.ToString());
        });
     }

问题是:

(1)当我在调试或发布模式下执行此操作时，我不会在文本框中看到结果，另一方面，当我逐步执行时，我会看到结果。我在这里错过了什么，为什么我看不到输出。

(2) RunParallel方法只显示一个线程，即使我设置了maxcount大于1。是否缺少任何代码逻辑，或者是因为测试应用程序很简单?

谢谢!