Why does this task-generating loop never stop?

Question

Very simple scenario. I am running a tight loop, generating tasks with each iteration. (Don't ask why.)

static void Main(string[] args)
{
    for (int i = 0; i < 1000 * 1000; i++)
        Task.Run(() => WriteHelloAsync(i));

    Console.ReadLine();
}

static Task WriteHelloAsync(int x)
{
    Console.WriteLine($"Hello {x}!");

    return Task.CompletedTask;
}

I can see in the console that it writes the iteration number incrementally. However, when it reaches the target 1 million, it just keeps on going.

But why?

Here's another duplicate: https://stackoverflow.com/questions/8898925/is-there-a-reason-for-cs-reuse-of-the-variable-in-a-foreach — 15ee8f99-57ff-4f92-890c-b56153, Jun 20 '17 at 15:55

15ee8f99-57ff-4f92-890c-b56153 · Answer 1 · 2017-06-20T19:24:11.710

2

This is the classic loop-variable closure problem in C#.

Your loop does stop at a million.

After it stops at a million, you make some large number of calls to WriteHelloAsync(i).

You're passing i to all of them. That lambda you're passing to Task.Run() isn't creating a new copy of i that holds the value i had at the time of that particular call to Task.Run(). They all have the same i, whose value keeps changing until the loop ends.

On my machine here, the first number I see is well into six digits, meaning that's the value of i the first time a task actually gets around to calling WriteHelloAsync(). Very shortly thereafter, it starts doing the million-million-million thing you see.

Try this:

static void Main(string[] args)
{
    for (int i = 0; i < 1000 * 1000; i++)
    {
        //  The scope of j is limited to the loop block.
        //  For each new iteration, there is a new j. 
        var j = i;
        Task.Run(() => WriteHelloAsync(j));
    }

    Console.ReadLine();
}

@Gigi points out that this will also work with a foreach rather than for:

foreach (var i in Enumerable.Range(0, 1000 * 1000))
{
    Task.Run(() => WriteHelloAsync(i));
}

edited Jun 20 '17 at 19:24

answered Jun 20 '17 at 15:42

15ee8f99-57ff-4f92-890c-b56153

36,786
7
62
114

Closures are magic. Can you mention the mechanism that determines _why_ the variable is reused? – apk Jun 20 '17 at 15:45
1

It's a closure. I don't understand. There it is. It's `i`. There's one `i`. – 15ee8f99-57ff-4f92-890c-b56153 Jun 20 '17 at 15:46
@EdPlunkett: that's not really helpful. There's one `j`, too. – Jacob Krall Jun 20 '17 at 16:35
@JacobKrall There's a million `j`s. Run the code. – 15ee8f99-57ff-4f92-890c-b56153 Jun 20 '17 at 16:36
1

I thought I had mastered closures. Always grateful to learn something new! – Gigi Jun 20 '17 at 18:12
Thing is, I was under the (wrong) assumption that you could do what I did because the integer is passed by value, so a copy would be made. – Gigi Jun 20 '17 at 18:13
Actually, in the answer you referred to, Lippert said that this was going to be fixed with C# 5. I wonder what happened with that? – Gigi Jun 20 '17 at 18:14
@Gigi That's actually a good question. You might [search his blog](https://ericlippert.com) and his answers here -- or [contact him directly](https://ericlippert.com/about-eric-lippert/) if you don't find anything. – 15ee8f99-57ff-4f92-890c-b56153 Jun 20 '17 at 18:18
1

@EdPlunkett I see it's explained in the comments of that answer. It was fixed in VS2012, but only when using `foreach`. `for` loops will still exhibit this behaviour. – Gigi Jun 20 '17 at 19:21
1

@Gigi Dang! Now I'm learning something new! – 15ee8f99-57ff-4f92-890c-b56153 Jun 20 '17 at 19:23

Why does this task-generating loop never stop?

1 Answers1