Les variables locales sont-elles threadsafe?

J’ai une classe comme celle ci-dessous:

class Program { static void Main(ssortingng[] args) { var outputWindow = new OutputWindow(); var threads = new List(); Action action = () => outputWindow.Display(20); for (int i = 0; i  action()) {Name = "Thread " + i}; threads.Add(thread); } foreach (var thread in threads) { thread.Start(); } } } public class OutputWindow { public void Display(int x) { for (int i = 0; i < x; i++) { Console.WriteLine(Thread.CurrentThread.Name + " Outputcounter: " + i); } } }

La question est: ce thread est-il sûr et cela entraînera-t-il une situation de concurrence critique pour la variable locale i dans la méthode d’affichage? Est-ce que tous les threads incrémentent la valeur de la variable “i” comme prévu (ce qui incrémente la valeur et n’encroît pas la valeur i des autres threads)

S’il s’agit de threadsafe, sera-t-il prudent de supposer que les variables locales déclarées dans une méthode sont toujours thread-safe et que les variables partagées sont celles qui nécessitent une synchronisation?

Merci, -Mike

Chaque appel de méthode aura un ensemble séparé de variables locales. Cependant, ces variables peuvent faire référence à des objects que d’autres méthodes utilisent également. Par exemple:

 public void AppendSomething(SsortingngBuilder builder) { builder.Append("Something"); }

Ici, le builder est toujours une variable locale (les parameters sont des variables locales) et chaque appel de AppendSomething aura une variable indépendante – mais vous pouvez appeler la méthode à partir de plusieurs threads en utilisant la même référence SsortingngBuilder . Cette méthode n’est donc pas thread-safe. (Comme SsortingngBuilder n’est pas thread-safe.)

Tant que vos données sont locales, oui, elles sont thread-safe. S’il fait référence à des données en dehors de cette méthode, alors ce n’est pas le cas.

Dans votre exemple, i n’est pas affecté par plusieurs threads (car vous créez la variable, définissez une valeur locale et incrémentez simplement la valeur).

Si je faisais référence à quelque chose en dehors de la méthode (par exemple un fichier), il ne serait pas thread-safe, car vous pourriez faire référence au même fichier sur différents threads.

Les variables locales sont thread-safe au sein d’une méthode tant que vous ne les passez pas à un autre thread. Si vous le faites, alors cela dépend.

Par exemple, dans votre code, tous les threads que vous créez ont un access partagé à outputWindow et aux threads . Si les objects ne sont pas thread-safe et que vous les appelez à partir de plusieurs threads, vous risquez de rencontrer des problèmes. Par exemple, si chaque thread essayait de se supprimer des threads à la fin, vous auriez un problème car List<> n’est pas sécurisé pour les threads en lecture / écriture.

Tous vos threads utilisent la même instance OutputWindow . Si l’appel de Display muté l’état de l’object, vous devez vous assurer que la mutation est threadsafe, sinon vous auriez une condition de concurrence critique.