为什么计数器在线程池中不起作用

Question

I made a simple application using the threadpool, but when I do the counter inside or outside the threadpool, it just returns zero in all cases or Non - sequential numbers?

My program [ I am sending 10 thousand valuable webrequest [API] and I knew that threadpool faster way? Because I want to send and receive 10,000 request within 5 to 10 minutes. ]

    public int Count;

    private void TaskCallBack(Object ThreadNumber)
    {
        MessageBox.Show(Count.ToString());  

        Interlocked.Increment(ref Count);
    }

    private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
    {
        try
        {
            //// Queue the task.
            for (int x = 0; x < 10; x++)
            {
                ThreadPool.QueueUserWorkItem(new WaitCallback(TaskCallBack));
            }

            this.Count = 0;
        }
        catch (Exception ex)
        {
            MessageBox.Show("Error : " + ex);
        }
    }

Answer 1

Well, you can have 10 threads all print out the initial value of Count before any one of them increments the value. There's no guarantee of consecutive order, either, should threads increment Count prior to other threads calling Show . To get both, use a mutex to control concurrent access to your callback's logic:

    public int Count;
    private readonly object _countLock = new Object();

    private void TaskCallBack(Object ThreadNumber)
    {
        lock( _countLock )
        {
            ++Count;
            MessageBox.Show(Count.ToString());
        }
    }

    private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
    {
        try
        {
            // this smells
            this.Count = 0;

            //// Queue the task.
            for (int x = 0; x < 10; x++)
            {
                ThreadPool.QueueUserWorkItem(new WaitCallback(TaskCallBack));
            }

        }
        catch (Exception ex)
        {
            MessageBox.Show("Error : " + ex);
        }
    }

Answer 2

When you use the Interlocked class to manipulate a variable, then all access to this variable must be done through the Interlocked class. Otherwise there is no guarantee that you'll get the current value of the variable. So, for starters, the Count variable should not be made public .

private int _count;

public int Count => Interlocked.CompareExchange(ref _count, 0, 0);

private void TaskCallBack(Object ThreadNumber)
{
    var localCount = Interlocked.Increment(ref _count);
    MessageBox.Show(localCount.ToString());
}