Identyfikator foreach i zamknięcia

Question

W dwóch poniższych fragmentach pierwszy z nich jest bezpieczny lub czy należy wykonać drugi?

Czy to bezpieczne, że każdy wątek gwarantuje wywołanie metody na Foo z tej samej iteracji pętli, w której wątek został utworzony?

Czy trzeba skopiować referencję do nowej zmiennej "local" do każdej iteracji pętli?

var threads = new List<Thread>(); 
foreach (Foo f in ListOfFoo) 
{  
    Thread thread = new Thread(() => f.DoSomething()); 
    threads.Add(thread); 
    thread.Start(); 
} 

-

var threads = new List<Thread>(); 
foreach (Foo f in ListOfFoo) 
{  
    Foo f2 = f; 
    Thread thread = new Thread(() => f2.DoSomething()); 
    threads.Add(thread); 
    thread.Start(); 
} 

Aktualizacja: Jak wskazano w odpowiedzi Jon Skeet, ten nie ma nic wspólnego ze specjalnie gwintowania.

Answer 1

Edytuj: to wszystkie zmiany w C# 5, ze zmianą w miejscu, gdzie zmienna jest zdefiniowana (w oczach kompilatora). Od C# 5 są one takie same.

---

Drugi jest bezpieczny; pierwszy nie jest.

Z foreach, zmienna jest zadeklarowana poza pętlę - tzn

Foo f; 
while(iterator.MoveNext()) 
{ 
    f = iterator.Current; 
    // do something with f 
} 

Oznacza to, że istnieje tylko 1 f pod względem zakresu zamknięcia, a gwinty mogą najprawdopodobniej się mylić - wywołanie metoda wielokrotnie w niektórych przypadkach, a nie w innych. Można rozwiązać ten problem z drugim deklaracji zmiennej wewnątrz pętlę:

foreach(Foo f in ...) { 
    Foo tmp = f; 
    // do something with tmp 
} 

To wtedy ma osobny tmp w każdym zakresie zamknięcia, więc nie ma ryzyka z tym problemem.

Oto prosty dowód problemu:

static void Main() 
    { 
     int[] data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; 
     foreach (int i in data) 
     { 
      new Thread(() => Console.WriteLine(i)).Start(); 
     } 
     Console.ReadLine(); 
    } 

Wyjścia (losowo):

1 
3 
4 
4 
5 
7 
7 
8 
9 
9 

dodać zmienną temp i to działa:

 foreach (int i in data) 
     { 
      int j = i; 
      new Thread(() => Console.WriteLine(j)).Start(); 
     } 

(każdy numer jeden raz, ale oczywiście zamówienie nie jest gwarantowane)

Answer 2

Foo f2 = f; 

punkty do tego samego odniesienia jako

f 

Więc nic nie stracił, a nic nie zyskał ...

Answer 3

swoją potrzebę użycia opcji 2, tworząc zamknięcie wokół zmieniającym zmiennej użyje wartość zmiennej, gdy używana jest zmienna, a nie w momencie tworzenia zamknięcia.

The implementation of anonymous methods in C# and its consequences (part 1)

The implementation of anonymous methods in C# and its consequences (part 2)

The implementation of anonymous methods in C# and its consequences (part 3)

Edycja: aby było jasne, w C# zamknięć są "zamknięcia leksykalne", co oznacza, że ​​nie uchwycić wartość zmiennej ale sama zmienna. Oznacza to, że podczas tworzenia zamknięcia zmiennej zmieniającej zamknięcie jest w rzeczywistości odniesieniem do zmiennej, a nie kopii jej wartości.

Edycja2: dodano linki do wszystkich wpisów na blogu, jeśli ktoś jest zainteresowany czytaniem o wewnętrznych kompilacjach.

Answer 4

Odpowiedzi Pop Catalina i Marca Gravella są poprawne. Wszystko, co chcę dodać, to link do my article about closures (który mówi zarówno o Javie, jak i C#). Pomyślałem, że może dodać trochę wartości.

EDYCJA: Myślę, że warto dać przykład, który nie ma nieprzewidywalności wątków. Oto krótki, ale kompletny program pokazujący oba podejścia. Lista "Zła akcja" wyświetla 10 razy dziesięć; lista „dobry uczynek” liczy się od 0 do 9.

using System; 
using System.Collections.Generic; 

class Test 
{ 
    static void Main() 
    { 
     List<Action> badActions = new List<Action>(); 
     List<Action> goodActions = new List<Action>(); 
     for (int i=0; i < 10; i++) 
     { 
      int copy = i; 
      badActions.Add(() => Console.WriteLine(i)); 
      goodActions.Add(() => Console.WriteLine(copy)); 
     } 
     Console.WriteLine("Bad actions:"); 
     foreach (Action action in badActions) 
     { 
      action(); 
     } 
     Console.WriteLine("Good actions:"); 
     foreach (Action action in goodActions) 
     { 
      action(); 
     } 
    } 
} 

Answer 5

To jest ciekawe pytanie i wydaje się, że widzieliśmy ludzi odpowie na wszystkie różne sposoby. Miałem wrażenie, że druga droga byłaby jedyną bezpieczną drogą. Udało mi się uzyskać szybki dowód:

class Foo 
{ 
    private int _id; 
    public Foo(int id) 
    { 
     _id = id; 
    } 
    public void DoSomething() 
    { 
     Console.WriteLine(string.Format("Thread: {0} Id: {1}", Thread.CurrentThread.ManagedThreadId, this._id)); 
    } 
} 
class Program 
{ 
    static void Main(string[] args) 
    { 
     var ListOfFoo = new List<Foo>(); 
     ListOfFoo.Add(new Foo(1)); 
     ListOfFoo.Add(new Foo(2)); 
     ListOfFoo.Add(new Foo(3)); 
     ListOfFoo.Add(new Foo(4)); 


     var threads = new List<Thread>(); 
     foreach (Foo f in ListOfFoo) 
     { 
      Thread thread = new Thread(() => f.DoSomething()); 
      threads.Add(thread); 
      thread.Start(); 
     } 
    } 
} 

Jeśli to uruchomisz zobaczysz, że opcja 1 nie jest bezpieczna.

Answer 6

W twoim przypadku można uniknąć problemu bez użycia trick kopiowania przez mapowanie ListOfFoo sekwencji wątków:

var threads = ListOfFoo.Select(foo => new Thread(() => foo.DoSomething())); 
foreach (var t in threads) 
{ 
    t.Start(); 
} 

Answer 7

Oba są bezpieczne, jak z C# w wersji 5 (.NET Framework 4.5). Zobacz to pytanie, aby uzyskać szczegółowe informacje: Has foreach's use of variables been changed in C# 5?