在 parallel.ForEach 循环中获取线程 ID

Question

Is there a way to find the thread id inside Parallel.FoEach loop. I tried using var threadId = Thread.CurrentThread.ManagedThreadId - 1; , but it didn't give me the correct index I was looking for.

Here is an simple example:

private void TestProgram()
    {
        int numThreads = 1;

        var values = new List<float>();
        for (int i = 0; i < numThreads; ++i)
        {
            values.Add(i);
        }

        var data = new List<int>();
        for (int i = 0; i < numThreads; ++i)
        {
            data.Add(i);
        }


        Parallel.ForEach(data, new ParallelOptions{MaxDegreeOfParallelism = numThreads}, i =>
            //foreach (var i in data)
        {
            var threadId = Thread.CurrentThread.ManagedThreadId - 1; // make the index to start from 0

            values[threadId] += i;
        });
    }

Even after setting the MaxDegreeOfParallelism to 1 , I still get the threadId to be greater than 1.

Is there a way to find the thread id inside Parallel.ForEach in above scenario?

Note: I could have used Parallel.For in the example I used. But my question is to find it inside Parallel.ForEach

Answer 1

Since Parallel.ForEach is part of the Task Library, Task.CurrentId will get you closer to what you are looking for:

   var data = new[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };


   Parallel.ForEach(data, new ParallelOptions { MaxDegreeOfParallelism = 4 }, i =>
   {
            Console.WriteLine(Task.CurrentId);
   });

output is 1 1 1 1 1 1 1 1 1 1 2 2 1

However, there is a disclaimer in the docs:

Task IDs are assigned on-demand and do not necessarily represent the order in which task instances are created. Note that although collisions are very rare, task identifiers are not guaranteed to be unique.

Answer 2

ThreadIDs are assigned by the underlying environment, and have no guarantee of being from 0 to [num of threads] or even being consistent from run to run.

There's only a few contracts with respect to threadIDs, and even these aren't guaranteed:

• You won't get a ThreadID 0
• ThreadID 1 is usually reserved for the Main thread

Answer 3

You will almost always get a thread ID that is greater than one. The parallel operations will be scheduled on a thread pool threads. Since those threads are created after the application has started a thread ID of one would already be started.

Answer 4

var data = new[] { 0,0,0,0,0,0,0,0,0,0,0,0,0};


    Parallel.ForEach(data, new ParallelOptions{MaxDegreeOfParallelism = 10}, i =>
    {
        Console.WriteLine(System.Threading.Thread.CurrentThread.ManagedThreadId);
    });

I get output:

180 180 180 180 180 180 180 180 62 62 62 62 180

This is typical. It's an environmental ID and have little to do with your foreach loop. You can also see that .NET did not feel the need to go up to MaxDegreeOfParallelism in this case (which was another of your assumptions).

Answer 5

Since this does not seem to be available in .NET just map the seemingly random values back to values which start at zero.

Example is below where you create resources as necessary, one for each thread. The 'locker' is to prevent threads from interfering with each other. Also note that Lists should be replaced with thread safe objects like System.Collections.Concurrent.ConcurrentBag

object locker = new object();
List<int> ids = new List<int>();
List<object> resources = new List<object>();

Parallel.For(0, 20000, x =>
{
    int thread_id = ids.IndexOf(Environment.CurrentManagedThreadId);
    if (thread_id == -1)
    {                    
        ids.Add(Environment.CurrentManagedThreadId);
        thread_id = ids.IndexOf(Environment.CurrentManagedThreadId);                    
    }

    while (resources.Count < thread_id + 1)
    {
        lock (locker)
        {
            resources.Add(new object());
        }
    }

    object resource = resources[thread_id];
    // do stuff with the resource
});