Threadpool issue Using C#

Question

I'm working on my university project. One of main requirement is to use multithreading (user can choose threads numbers).

I'm new in C# and based on internet research. I choose ThreadPool.

I spent a lot of time observing how the threads act using parallel watch in VS and i have no idea how this thing works. For example threadNumber = 10 but parallel watch shows only 4 activated threads.

Here is my code:

public void calculateBeta()
    {
        var finished = new CountdownEvent(1);
        for (int i = 0; i < threadNumber; i++)
        {
            finished.AddCount();
            ThreadPool.QueueUserWorkItem(
            (state) =>
            {
                try
                {
                   doSth();
                }
                finally
                {
                    finished.Signal();
                }
            });
        }
        finished.Signal();
        finished.Wait();
    }

What am I doing wrong? I tried to test this code with many different values of threads number and it didn't work as i looked for.

EDIT:

 private void myTask(object index)
    {

            int z = (int)index;
            double[] result = countBeta(createTableB(z), createTableDiagonalA(z));
            int counter = 0;
            if ((rest != 0) && (z == threadNumber - 1))
            {
                for (int j = z * numbersInRow; j < (z + 1) * numbersInRow + rest; j++)
                {
                    N[j] = result[counter];
                    counter++;
                }
            }
            else
            {
                for (int j = z * numbersInRow; j < (z + 1) * numbersInRow; j++)
                {
                    N[j] = result[counter];
                    counter++;
                }
            }
            threads[z] = true;
    }


public void calculateBeta()
    {
        N = new double[num];
        setThreadNumber(2);
        checkThreadNumber();
        setNumberInRow();
        setRest();
        threads = new bool[threadNumber];
        for (int i = 0; i < threadNumber; i++)
        {
            Thread thread = new Thread(this.myTask);
            thread.IsBackground = true;
            thread.Start(i);
        }
        while (!checkThreads())
        {
        }
    }

private bool checkThread()
    {
        bool result = true;
        for (int i = 0; i < threads.Length; i++)
        {
            if (!threads[i])
                result = false;
        }

        return result;
    }

static void Main(string[] args)
    {


        Jacobi jacobi = new Jacobi();
        Console.WriteLine("Metoda Jacobiego");
        Console.WriteLine("Rozwiazywanie ukladu n-rownan z n-niewiadomymi Ax=b");
        jacobi.getNum();
        jacobi.getA();
        jacobi.getB();
        jacobi.calculateBeta();
        jacobi.calculateM();
        jacobi.calculateX();
        jacobi.countNorms();
        Console.ReadLine();
    }

I need results from calculateBeta to further calculations. Sometimes threads are not finished yet but the program moves forward without data that need to be provided by threads. I'm using bool variable now but this solution is not an elegant way to deal with it(Creating bool table, checking if all thread are fnished) How can i manage with that in a different way?

Answer 1

// Array of threads launched. 
// This array is useful to trace threads status.
Thread[] threads;

private void myTask(object index)
{
    Console.Write("myTask {0} started\n", index);
    Console.Write("myTask {0} finisced\n", index);
}

public void calculateBeta(UInt16 threadNumber)
{
    // Allocate a new array with size of requested number of threads
    threads = new Thread[threadNumber];

    // For each thread
    for (int i = 0; i < threadNumber; i++)
    {
        // Thread creation
        threads[i] = new Thread(this.myTask);

        // IsBackground set to true grants that the allication can be "killed" without wait for all threads termination
        // This is useful in debug to be sure that an error in task doesn't freeze the app.
        // Leave it to false in release
        #if DEBUG
        threads[i].IsBackground = true;
        #endif

        // Start the thread
        threads[i].Start(i);
    }

    // Waits until all threads complete.
    while (!checkThreads());
}

private bool checkThreads()
{
    bool result = true;
    for (int i = 0; i < threads.Length; i++)
    {
        // If the thread wasn't disposed
        if (threads[i] != null)
        {
            // Check if the thead is alive (means is working)
            if (threads[i].IsAlive == true) 
            {
                result = false;
            }
            else // The thread is not working 
            {
                // Dispose the thread
                threads[i].Join();
                // Set pointer to null to signal that the task was 
                threads[i] = null;
            }
        }
    }

    return result;
}


private void Button_Click(object sender, RoutedEventArgs e)
{
    Console.Write("Starting tasks!!\n");

    calculateBeta(10);

    Console.Write("All tasks finished!!\n");
}

Answer 2

This is because you're using ThreadPool to manage your threads. It will create a certain number of threads based on many factors. You can tweak some of the settings but by and large when you commit to using ThreadPool to managing your threads you commit to a black box. Check out GetMaxThreads and GetMinThreads and their setter counterparts for some of your options.

Check out this ThreadPool Architecture article on MSDN. It gives good background to the hows and whys of the class. But in the introductory paragraph you will see this sentence, which is key to your conundrum:

The thread pool is primarily used to reduce the number of application threads and provide management of the worker threads.

If you want to have the kind of control where you launch 10 threads in quick succession you should avoid ThreadPool and just manage the threads yourself. Here is a simple, absolutely minimal example of launching ten threads and also passing different data to each, in this case an index:

void ButtonClickHandlerOrSomeOtherMethod()  
{
    for (int i=1; i<=10; i++) // using a 1-based index
    {
        new Thread(ThreadTask).Start(i);
    }
}

void ThreadTask(object i) 
{
    Console.WriteLine("Thread " + i + " ID: " + Thread.CurrentThread.ManagedThreadId);
}

And some sample output:

Thread 1 ID: 19
Thread 2 ID: 34
Thread 3 ID: 26
Thread 4 ID: 5
Thread 5 ID: 36
Thread 6 ID: 18
Thread 7 ID: 9
Thread 8 ID: 38
Thread 9 ID: 39
Thread 10 ID: 40

Follow-up code demonstrating synching with threads and "waiting" until they are all finished:

void ButtonClickHandlerOrSomeOtherMethod() 
{
    // need a collection of threads to call Join after Start(s)
    var threads = new List<Thread>();

    // create threads, add to List and start them
    for (int i=1; i<=10; i++) {
        var thread = new Thread(ThreadTask);
        threads.Add(thread);
        // a background thread will allow main app to exit even
        // if the thread is still running
        thread.IsBackground = true;
        thread.Start(i);
    }

    // call Join on each thread which makes this thread wait on
    // all 10 other threads
    foreach (var thread in threads) 
        thread.Join();

    // this message will not show until all threads are finished
    Console.WriteLine("All threads finished.");
}

void ThreadTask(object i) 
{
    Console.WriteLine("Thread " + i + " ID: " + Thread.CurrentThread.ManagedThreadId);
    // introducing some randomness to how long a task "works on something"
    Thread.Sleep(100 * new Random().Next(0, 10));
    Console.WriteLine("Thread " + i + " finished.");
}

Answer 3

The whole design of the thread pool is that it doesn't have to create a new actual thread every time a new item is queued up. If the pool notices that it has items pending in the queue for an extended period of time it will eventually start spinning up new threads, over time. If you're continually saturating the thread pool with operations, you'll see the number of actual threads rise. It will also only add new threads up to a limit; based on what it feels is going to have the best throughput. For example, it will avoid creating a lot more threads than cores assuming all of the threads are actively running CPU bound work.

The idea of using the thread pool is if you don't care how many actual threads there are, but rather just want to have efficient throughput of the operations that you have, allowing the framework lots of freedom on how to best optimize that work. If you have very specific requirements as to how many threads you have, you'll need to create threads manually rather than using a pool.