Regarding local variable passing in Thread

by

Each thread gets its own stack. The problem that you are facing has nothing to do with stack. The problem is the way it is generating code for your anonymous delegate. Use tool like refelector to understand the code that it is generating. The following will fix your problem:

static void Main() 
        {
            for (int i = 0; i < 10; i++)
            {
                int capture = i;
                new Thread(() => Console.Write(capture)).Start();
            }
        }

Under the hood

Whenever you use a variable from outer scope (in your case variable i) in anonymous delegate, the compiler generates a new class that wraps anonymous function along with the data that it uses from the outer scope. So in your case the generated class contains – one function and data member to capture the value of variable i. The class definition looks something like:

class SomeClass
{
    public int i { get; set; }

    public void Write()
    {
        Console.WriteLine(i);
    }
}

The compiler re-writes your code as follows:

SomeClass someObj = new SomeClass();
for (int i = 0; i < 10; i++)
{
    someObj.i = i;
    new Thread(someObj.Write).Start();
}

and hence the problem – that you are facing. When you capture a variable, the compiler does the following:

for (int i = 0; i < 10; i++)
{
    SomeClass someObj = new SomeClass();
    someObj.i = i;
    new Thread(someObj.Write).Start();
}

Note the difference in SomeClass instantiation. When you capture a variable, it creates as many instances as there are number of iterations. If you do not capture a variable, it tries to use the same instance for all iterations.

Hope, the above explanation will clarify your doubt.

Thanks

More Related Contents:

  1. What’s wrong with using Thread.Abort()
  2. Run async method regularly with specified interval
  3. How can I set processor affinity to a thread or a Task in .NET?
  4. How to pass parameters to ThreadStart method in Thread?
  5. How to invoke a UI method from another thread
  6. The calling thread cannot access this object because a different thread owns it [duplicate]
  7. Updating an ObservableCollection in a separate thread
  8. Does a locked object stay locked if an exception occurs inside it?
  9. Unhandled exceptions in BackgroundWorker
  10. Benefits of using async and await keywords
  11. A reproducible example of volatile usage
  12. thread with multiple parameters
  13. Event handlers not thread safe? [duplicate]
  14. Difference between lock(locker) and lock(variable_which_I_am_using)
  15. Looking for an example of a custom SynchronizationContext (Required for unit testing)
  16. What is the difference between ManualResetEvent and AutoResetEvent in .NET?
  17. Lock (Monitor) internal implementation in .NET
  18. .NET 4.0 and the dreaded OnUserPreferenceChanged Hang
  19. Advantage of using Thread.Start vs QueueUserWorkItem
  20. How do I spawn threads on different CPU cores?
  21. Reading an int that’s updated by Interlocked on other threads
  22. How to get awaitable Thread.Sleep?
  23. Thread parameters being changed
  24. Queue of async tasks with throttling which supports muti-threading
  25. ThreadStaticAttribute in ASP.NET
  26. Handling events from out-of-proc COM server in managed STA application
  27. Starting a new thread in a foreach loop
  28. Multithreaded NamePipeServer in C#
  29. Wrapping ManualResetEvent as awaitable task
  30. Half – fences and full fences? [duplicate]

Leave a Comment