For Loop result in Overflow with Task.Run or Task.Start

Question

got a Problem, hope someone can help me out.

i try to start 4 Task in an Loop but im getting an ArgumentOutOfRangeException:

 for (int i = 0; i < 4; i++)
     {
          //start task with current connection
          tasks[i] = Task<byte[]>.Run(() => GetData(i, plcPool[i]));
     }

The Loop gets an Overflow because i = 4

if i start the Tasks without a Loop, they run without any Problems:

            tasks[0] = Task<byte[]>.Run(() => GetData(0, plcPool[0]));
            tasks[1] = Task<byte[]>.Run(() => GetData(1, plcPool[1]));
            tasks[2] = Task<byte[]>.Run(() => GetData(2, plcPool[2]));
            tasks[3] = Task<byte[]>.Run(() => GetData(3, plcPool[3]));

dont know why? The Tasks GetData from a Siemens PLC via Socket Connection. The PLC Supports up to 32 Connections. I receive 200 Bytes per Connection.

 private byte[] GetData(int id, PLC plc)
    {
        switch (id)
        {
            case 0:
                return plc.ReadBytes(DataType.DataBlock, 50, 0, 200);
            case 1:
                return plc.ReadBytes(DataType.DataBlock, 50, 200, 200);
            case 2:
                return plc.ReadBytes(DataType.DataBlock, 50, 500, 200);
            case 3:
                return plc.ReadBytes(DataType.DataBlock, 50, 700, 200);
            case 4:
                return plc.ReadBytes(DataType.DataBlock, 50, 900, 117);
            default:
                return null;
        }
    }

any idea?

Regards Sam

Answer 1

It's probably caused by a closure problem.

Try this:

 for (int i = 0; i < 4; i++)
 {
      //start task with current connection
      int index = i;
      tasks[index] = Task<byte[]>.Run(() => GetData(index, plcPool[index]));
 }

What is probably happening is that when the last thread starts running, the loop has already incremented i to 4, and that's the value that gets passed to GetData(). Capturing the value of i into a separate variable index and using that instead should solve that issue.

As an example, if you try this code:

public static void Main()
{
    Console.WriteLine("Starting.");

    for (int i = 0; i < 4; ++i)
        Task.Run(() => Console.WriteLine(i));

    Console.WriteLine("Finished. Press <ENTER> to exit.");
    Console.ReadLine();
}

it will often give you this kind of output:

Starting.
Finished. Press <ENTER> to exit.
4
4
4
4

Change that code to:

public static void Main()
{
    Console.WriteLine("Starting.");

    for (int i = 0; i < 4; ++i)
    {
        int j = i;
        Task.Run(() => Console.WriteLine(j));
    }

    Console.WriteLine("Finished. Press <ENTER> to exit.");
    Console.ReadLine();
}

and you get something like

Starting.
Finished. Press <ENTER> to exit.
0
1
3
2

Note how it is STILL NOT NECESSARILY IN ORDER! You will see all the correct values printed out, but in an indeterminate order. Multithreading is tricksy!

Answer 2

In 2021, You should really just use the built in Parallel.For for this. It's quite simple to achieve your desired effect:

ConcurrentBag<byte[]> results = new ConcurrentBag<byte[]>();

ParallelLoopResult result = Parallel.For(0, 4, (i, state) => {
   results.Add(GetData(i, plcPool[i]));
});

Answer 3

In C# 5, the loop variable of a foreach will be logically inside the loop, and therefore closures will close over a fresh copy of the variable each time. The "for" loop will not be changed.

Another way is that：

1. Create tasks
2. Run the tasks.
3. Wait all task to finish.

The demo code as follow:

 internal class Program
{
    private static void Main(string[] args)
    {
        Task[] tasks = new Task[4];

        for (int i = 0; i < 4; i++)
        {
            //start task with current connection
            tasks[i] = new Task<byte[]>(GetData,i);
        }

        foreach (var task in tasks)
        {
            task.Start();
        }

        Task.WaitAll(tasks);

        Console.Read();
    }

    private static byte[] GetData(object index)
    {
        var i = (int) index;
        switch (i)
        {
            case 0:

                //return plc.ReadBytes(DataType.DataBlock, 50, 0, 200);
                Console.WriteLine(i);
                return new byte[] { };
            case 1:
            //return plc.ReadBytes(DataType.DataBlock, 50, 200, 200);
            case 2:
                Console.WriteLine(i);
                return new byte[] { };
            //return plc.ReadBytes(DataType.DataBlock, 50, 500, 200);
            case 3:
                Console.WriteLine(i);
                return new byte[] { };
            //return plc.ReadBytes(DataType.DataBlock, 50, 700, 200);
            case 4:
                //return plc.ReadBytes(DataType.DataBlock, 50, 900, 117);
                Console.WriteLine(i);
                return new byte[] { };

            default:
                return null;
        }
    }
}

OUTPUT:

    3  
    1  
    0  
    2  

Note: it's new Task<byte[]>(GetData,i); not new Task<byte[]>(()=>GetData(i));

()=>v means "return the current value of variable v", not "return the value v was back when the delegate was created". Closures close over variables, not over values.

So the new Task<byte[]>(GetData,i); have no " Closures Problem "