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:

1. La variable local es de un tipo primitivo como int o double .
2. La variable local es de un tipo de referencia como 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 lock

entonces 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.