Del modelo de memoria de Java, sabemos que cada subproceso tiene su propia pila de subprocesos y que las variables locales se colocan en la propia pila de subprocesos de cada subproceso.
Y que otros subprocesos no pueden acceder a estas variables locales.
Entonces, ¿en qué caso deberíamos sincronizar las variables locales?
Estás hablando del siguiente caso:
public class MyClass { public void myMethod() { //Assume Customer is a Class Customer customer = getMyCustomer(); synchronized(customer) { //only one thread at a time can access customer object which ever holds the lock } } } En el código anterior, customer es una variable de referencia local, pero aún está utilizando un bloque sincronizado para restringir el acceso al objeto al que apunta el customer ( por un solo hilo a la vez ).
En el modelo de memoria de Java, los objetos viven en el montón (aunque las referencias son locales a un subproceso que vive en una pila) y la sincronización se trata de restringir el acceso a un objeto en el montón exactamente un subproceso a la vez.
En resumen, cuando dice variable local (no primitiva), solo la referencia es local, pero no el objeto real en sí, es decir, en realidad se refiere a un objeto en el montón al que pueden acceder muchos otros subprocesos. Debido a esto, necesita sincronización en el objeto para que un solo subproceso solo pueda acceder a ese objeto a la vez.
Hay dos situaciones:
int o double .ArrayList .En la primera situación, no puede sincronizar, ya que solo puede sincronizar en Objetos (a los que apuntan las variables de tipo de referencia).
En la segunda situación, todo depende de a qué apunte la variable local. Si apunta a un objeto al que otros subprocesos (pueden) también apuntar, entonces debe asegurarse de que su código esté correctamente sincronizado.
Ejemplos: asignó la variable local de un campo static o de instancia, o obtuvo el objeto de una colección compartida.
Sin embargo, si el objeto se creó en su subproceso y solo se asignó a esa variable local, y nunca proporciona una referencia a él desde su subproceso a otro subproceso, y la implementación de objetos en sí tampoco proporciona referencias, entonces usted no necesita preocuparse por la sincronización.
El punto es: la sincronización se realiza con un propósito. Lo usa para asegurarse de que exactamente un subproceso pueda realizar alguna actividad especial digna de protección en un momento dado.
Por lo tanto: si necesita sincronización, siempre se trata de más de un hilo. Y, por supuesto, luego debe bloquear algo a lo que todos esos hilos tengan acceso.
O en otras palabras: no tiene sentido cerrar la puerta con llave para evitar entrar al edificio.
Pero, como señala la otra respuesta: en realidad depende de la definición de variable "local". Digamos que tienes:
void foo() { final Object lock = new Object(); Thread a = new Thread() { uses lock Thread b = new Thread() { uses lockentonces seguro, esa variable "local" se puede usar como bloqueo para esos dos hilos. Y más allá de eso: ese ejemplo funciona porque la sincronización ocurre en el monitor de un objeto específico. Y los objetos residen en el montón. Todos ellos.