Varios hilos que pasan una referencia de objeto al método de ayudante estático

Question

Solo soy un principiante en Java y he tropezado con aplicaciones de subprocesos múltiples. Sé que esta pregunta es similar a algunas publicaciones aquí, pero no pude encontrar una mejor respuesta para mi consulta. Básicamente, quiero pasar un objeto a un método estático y el método simplemente devolverá un resultado basado en los valores/propiedades del objeto. Para cada llamada, estoy creando una nueva instancia del objeto y no hay ninguna posibilidad de que modifique el objeto dentro del método. Ahora, mi pregunta es, ¿creará JVM una nueva instancia del método estático y sus variables locales en la pila (excluyendo el objeto tal como estará en el montón) para cada llamada por múltiples hilos? Para una visión clara de lo que quiero lograr, aquí está mi código:

TestConcurrent.java

import classes.Player; 

public class TestConcurrent 
{ 
    private static int method(Player player) 
    { 
     int y = (player.getPoints() * 10) + 1; 

      try { 
        Thread.sleep(1000); 
      } catch (InterruptedException e) {} 

      return ++y; 
    } 

    public static void main(String[] args) throws Exception 
    { 
     // Create 100 threads 
     for(int i=1;i<=100;i++) 
     { 
      final int j = i; 
      // Create a new Thread 
      new Thread() 
      { 
       public void run() 
       { 
        // Create a new instance of the Player class 
        Player player = new Player(j,j,"FirstName" + j, "LastName" + j); 
        // Call static method() and pass a new instance of Player class 
        System.out.println("Thread " + j + ": " + TestConcurrent.method(player)); 
        // Check the values of the Player class after the call to the static method() 
        System.out.println("Player" + player.getAcctId() + " : Points=" + player.getPoints() + " Name=" + player.getFirstName() + " " + player.getLastName()); 
       } 
      }.start(); 
     } 
    } 

} 

Player.java

package classes; 

public class Player 
{ 
    private int acctId, points; 
    String firstName, lastName; 

    public Player(int acctId, int points, String firstName, String lastName) 
    { 
     this.acctId = acctId; 
     this.points = points; 
     this.firstName = firstName; 
     this.lastName = lastName; 
    } 

    public int getAcctId() { 
     return acctId; 
    } 
    public void setAcctId(int acctId) { 
     this.acctId = acctId; 
    } 
    public int getPoints() { 
     return points; 
    } 
    public void setPoints(int points) { 
     this.points = points; 
    } 
    public String getFirstName() { 
     return firstName; 
    } 
    public void setFirstName(String firstName) { 
     this.firstName = firstName; 
    } 
    public String getLastName() { 
     return lastName; 
    } 
    public void setLastName(String lastName) { 
     this.lastName = lastName; 
    } 
} 

SALIDA:

Como no puse una palabra clave sincronizada, th La salida será diferente cada vez y se ve similar a lo siguiente: (la salida es correcta y es exactamente lo que estoy esperando, solo quiero aclarar que estoy en el camino correcto ya que no quiero usar la sincronización como que se ralentizará el proceso, porque cada hilo tendrá que esperar a que el otro hilo para terminar antes de que pueda llamar al método estático)

Thread 2: 22 
Player8 : Points=8 Name=FirstName8 LastName8 
Thread 22: 222 
Thread 26: 262 
Thread 23: 232 
Player23 : Points=23 Name=FirstName23 LastName23 
Thread 21: 212 
Player21 : Points=21 Name=FirstName21 LastName21 
Thread 25: 252 
Player25 : Points=25 Name=FirstName25 LastName25 
Thread 20: 202 
Thread 19: 192 
Thread 24: 242 
Player24 : Points=24 Name=FirstName24 LastName24 
Player9 : Points=9 Name=FirstName9 LastName9 
Thread 28: 282 

Answer 1

se JVM crear una nueva instancia del método estático y su local de variables en la Pila (excluyendo el objeto como estará en el Heap) para cada llamada por múltiples hilos?

Sí, eso es exactamente.

Si un método estático solo se refiere a las variables locales, es automáticamente seguro para subprocesos. (De hecho, esto también se aplica a los métodos no estáticos).

Hablando en general, diría que debe evitar static si es posible. En general, hace que el código sea más difícil de probar y razonar debido al hecho de que los miembros estáticos son, en cierto sentido, globales.

Answer 2

static métodos no son un problema, solo static variables se compartirán entre subprocesos.

Así que dos hilos que invocan

public static int sum(int a, int b) { 
    int tmp = a + b; 
    return tmp; 
} 

no van a tener problemas.

static int tmp; 

public static int sum(int a, int b) { 
    tmp = a + b; 
    return tmp; 
} 

fallará multi-hilo, porque un hilo puede sobrescribir anothers tmp valor.

Las variables locales, incluso en los métodos static, son aún locales y por lo tanto seguros.

El uso de métodos static es bueno. Resalta que el método no requiere acceso a variables de objeto.Usar static variables no constantes es propenso a errores, evite esto a toda costa (y use la sincronización en una constante si necesita acceder a la variable).