Questions related to Threadpool C#. Failure to complete execution of one thread

Question

I have this function below and i want to understand this. Also if there any documentations you van point me to. I have read about ManualResetEvent and ThreadPool from msdn

public void GetParametersThreadPool()
{
    var toProcess = 50;
    ManualResetEvent[] threadsActive = new ManualResetEvent[50];
    for (int handleIndex = 0; handleIndex < 50; ++handleIndex)
    {
        threadsActive[handleIndex] = new ManualResetEvent(false);

        ThreadPool.QueueUserWorkItem(new WaitCallback(delegate(object state)
            {
                string reportUrl = TeamFoundationTestConfig.TeamFoundationReportPath("TaskGroupStatus");
                ReportUri reportUri = ReportUri.Create(reportUrl);
                Log.Message(TraceEventType.Information, "ReportUri = {0}".InvariantFormat(reportUri.UriString));
                IList<Parameter> parameters = this.RemoteReportingServiceFactory.CreateReportParameterProvider().GetParameters(reportUri, SessionContext);
                Assert.IsNotNull(parameters, "Assertion failed: Parameters cannot be null. GetParameters failed");
                Assert.IsTrue(parameters.Count > 0, "Assertion failed: No parameters available on the report page. GetParameters failed. Count = {0}".InvariantFormat(parameters.Count));
                if (Interlocked.Decrement(ref toProcess) == 0)
                {
                    threadsActive[handleIndex].Set();
                }
            }), null);

        //// Wait for all the threads to complete before starting the next set of requests.
        threadsActive[handleIndex].WaitOne(); 
    }   
}

When i update this line of code : ManualResetEvent[] threadsActive = new ManualResetEvent[100];It gives en exception saying less than 64 only.

Currently when i run this stress tests it hangs on the line where i do Logging and doesn't finish running. What am i doing wrong?

If there is any better way to do this? Also just for information i referenced one other question from stackoverflow to create this function on my own

C# Execute Method (with Parameters) with ThreadPool

Is this project code or a unit-test? – H H Feb 09 '14 at 09:31 — H H, Feb 09 '14 at 09:31

sunside · Accepted Answer · 2014-02-09T12:33:49.313

2

Depending on your .NET version you might want to use Task and Task.WaitAll(..), it comes with .NET 4. There's also CountdownEvent in your toolkit.

Using tasks is often as simple as

var t = Task.Factory.StartNew(() => { your code });
t.Wait();

If, for any reason, the Task Parallel Library is not an option, you might want to think about using Semaphores (SemaphoreSlim in .NET 4).

As for the 64 limit, this is an operating system enforced limit; Sadly there's no way around it.

edited Feb 09 '14 at 12:33

answered Feb 09 '14 at 01:55

sunside

8,069
9
51
74

where does it define if i want to call the same function about 100 times in parallel? – StackOverflowVeryHelpful Feb 09 '14 at 02:57
1

I'm not sure if I understand correctly, but there's nothing wrong with having a `Task[] array = new Task[100]` (or a `List` for that matter) initialized with a `for`-Loop; `Task.WaitAll(array);` would do the waiting. – sunside Feb 09 '14 at 03:02
@Markus, did you meant `t.Wait()` rather than `t.WaitOne()`? – avo Feb 09 '14 at 06:42
@avo, yes, thanks for pointing it out. Typical 3-in-the-morning bug. – sunside Feb 09 '14 at 12:34
Task[] listOfTask = new Task[100]; for (int i = 0; i < 100; i++) { listOfTask[i] = Task.Factory.StartNew(() => { }); } Task.WaitAll(listOfTask); – StackOverflowVeryHelpful Feb 09 '14 at 18:05

score 2 · Answer 2 · answered Feb 09 '14 at 02:52

WaitOne Blocks the current thread until the current WaitHandle receives a signal, you are writing mulit-thread code but this method is sync method actually

create a variable that keeps track of the number of running tasks:

var toProcess = 50;

create one signal instead of array

   ManualResetEvent signal = new ManualResetEvent(false);

for (int handleIndex = 0; handleIndex < 50; ++handleIndex)
    {


        ThreadPool.QueueUserWorkItem(new WaitCallback(delegate(object state)
            {
                string reportUrl = TeamFoundationTestConfig.TeamFoundationReportPath("TaskGroupStatus");
                ReportUri reportUri = ReportUri.Create(reportUrl);
                Log.Message(TraceEventType.Information, "ReportUri = {0}".InvariantFormat(reportUri.UriString));
                IList<Parameter> parameters = this.RemoteReportingServiceFactory.CreateReportParameterProvider().GetParameters(reportUri, SessionContext);
                Assert.IsNotNull(parameters, "Assertion failed: Parameters cannot be null. GetParameters failed");
                Assert.IsTrue(parameters.Count > 0, "Assertion failed: No parameters available on the report page. GetParameters failed. Count = {0}".InvariantFormat(parameters.Count));
                if (Interlocked.Decrement(ref toProcess) == 0)
                {
                    signal.Set();
                }
            }), null);


    }   

    signal.WaitOne();

don't put signal.WaitOne() in the for loop, that will block the thread.

finally, consider use Task if you are working on .net 3.5 or higher

Thanks for sharing the flaws in my method. I gave you 1 up for finding it. Also thanks for your suggestion on using Task — StackOverflowVeryHelpful, Feb 09 '14 at 18:06

score 0 · Answer 3 · answered Feb 09 '14 at 02:08

0

As suggested, you should probably use Tasks if you can. Prior to their availability, it was possible to do what you want with just two WaitHandles. Instead of using one WaitHandle per thread, you use one WaitHandle for all threads. The waiting thread counts the number of times the WaitHandle is signalled and continues only when all signals have been received.

answered Feb 09 '14 at 02:08

jmcilhinney

50,448
5
26
46

Isn't that technically a semaphore? – sunside Feb 09 '14 at 14:19
@Markus, it doesn't really seem so to me. I'm not seeing how a Semaphore object could be used to achieve the same end. That said, I've never actually used a Semaphore so maybe I'm missing something. – jmcilhinney Feb 10 '14 at 00:02
1

A problem of having an Semaphore initialized with negative values, true; That's not possible directly in C#. A workaround would be to initialize the Semaphore with count `N` and `0` free capacity (i.e. making it 'full'), have every worker thread `Release()` on the Semaphore once work is done and the waiting task `WaitOne()` for `N` times. – sunside Feb 10 '14 at 06:41

Questions related to Threadpool C#. Failure to complete execution of one thread

3 Answers3