Pourquoi sont des variables locales des threads en Java

Question

Je lisais le multi-thread en Java et je tombe sur cet

Les variables locales sont des threads en Java.

Depuis lors, j'ai pensé Comment/Pourquoi les variables locales sont thread-safe.

Quelqu'un peut-il s'il vous plaît laissez-moi savoir.

Answer 1

Lorsque vous créez un fil, elle a sa propre pile créé. Deux fils va avoir deux piles et un thread ne partage jamais son stack avec les autres fil.

Toutes les variables locales définies dans votre programme sera alloué de la mémoire dans la pile (Comme Jatin commenté, de la mémoire signifie ici, de référence-valeur pour les objets et la valeur pour les types primitifs) (Chaque appel de méthode par un thread crée un cadre de pile sur sa propre pile). Dès que l'exécution de la méthode est complétée par ce fil, la trame de pile sera supprimé.

Il y a une grande conférence par le professeur de l'université Stanford dans youtube qui peut vous aider dans la compréhension de ce concept.

Answer 2

Les variables locales sont stockées dans chaque thread propre pile. Cela signifie que les variables locales ne sont jamais partagées entre les threads. Cela signifie également que toutes les variables primitives sont thread-safe.

public void someMethod(){

   long threadSafeInt = 0;

   threadSafeInt++;
}

Local des références à des objets sont un peu différentes. La référence elle-même n'est pas partagé. L'objet référencé cependant, n'est pas stocké dans chacun des fils de la pile locale. Tous les objets sont stockés dans le segment de mémoire partagée. Si un objet créé localement n'échappe pas à la méthode qu'il a été créé, il est thread-safe. En fait, vous pouvez également les transmettre à d'autres méthodes et d'objets aussi longtemps qu'aucune de ces méthodes ou des objets que l'objet passé à la disposition des autres threads

Answer 3

Pensez à des méthodes telles que les définitions de la fonctionnalité. Lorsque deux threads s'exécutent de la même méthode, ils ne sont en aucune façon liés. Ils auront chacun créer leur propre version de chaque variable locale, et sera incapable d'interagir avec d'autres personnes en aucune façon.

Si les variables ne sont pas locales, (comme les variables d'instance définie en dehors d'une méthode au niveau de la classe, alors qu'ils sont attachés l'un à l'instance (et non pas d'une seule exécution de la méthode). Dans ce cas, deux threads s'exécutant la même méthode, à la fois de voir l'une des variables, et ce n'est pas thread-safe.

Tenir compte de ces deux cas:

public class NotThreadsafe {
    int x = 0;
    public int incrementX() {
        x++;
        return x;
    }
}

public class Threadsafe {
    public int getTwoTimesTwo() {
        int x = 1;
        x++;
        return x*x;
    }
}

Dans la première, les deux threads s'exécutant sur la même instance de l' NotThreadsafe voient le même. x. Cela pourrait être dangereux, parce que les threads tentent de changer x! Dans le deuxième, deux threads s'exécutant sur la même instance de l' Threadsafe va voir totalement différentes versions de x, et ne pouvez pas en effet les uns des autres.

Answer 4

Chaque invocation de méthode a ses propres variables locales et, bien évidemment, une invocation de méthode qui se passe dans un seul thread. Une variable est mise à jour uniquement par un seul thread est intrinsèquement thread-safe.

Cependant, gardez un œil sur ce que signifie exactement ceci: seules les écritures à la variable elle-même sont thread-safe; des appels de méthodes sur l'objet qu'il désigne n'est pas intrinsèquement thread-safe. En va de même pour la mise à jour directe de l'objet de variables.

Answer 5

En plus de l'autre les réponses telles que Nambari de l'.

Je tiens à souligner que vous pouvez utiliser une variable locale dans une anoymous méthode de type:

Cette méthode peut être appelée dans d'autres threads qui pourrait compromettre threadsafety, donc java forces toutes les variables locales utilisées dans anoymous types pour être déclaré comme définitif.

Considérez ceci illégal code:

public void nonCompilableMethod() {
    int i=0;
    for(int t=0; t<100; t++)
    {
      new Thread(new Runnable() {
                    public void run() {
                      i++; //compile error, i must be final:
                      //Cannot refer to a non-final variable i inside an
                      //inner class defined in a different method
                    }
       }).start();
     }
  }

Si java ne le permettent (comme en C# à l'aide de "fermetures"), une variable locale ne serait plus des threads en toutes circonstances. Dans ce cas, la valeur de i à la fin de tous les threads n'est pas garantie 100.