Question: From the Java memory model, we know that every thread has its own thread stack, and that local variables are placed in each thread's own thread stack.

And that *other* threads can't access these local variables.

So in which case should we synchronize on local variables?

Answer: 
There are two situations:

1. The local variable is of a primitive type like `int` or `double`.
2. The local variable is of a reference type like `ArrayList`.

In the first situation, you *can't* synchronize, as you can only synchronize on Objects (which are pointed to by reference-type variables).

In the second situation, it all depends on what the local variable points to. If it points to an object that other threads (can) also point to, then you need to make sure that your code is properly synchronized.

Examples: you assigned the local variable from a `static` or instance field, or you got the object from a shared collection.

If, however, the object was created in your thread and only assigned to that local variable, and you never give out a reference to it from your thread to another thread, and the objects implementation itself also doesn't give out references, then you don't need to worry about synchronization.
The point is: synchronization is done for a purpose. You use it to ensure that **exactly** one thread can do some special protection-worthy activity at any given time. 

Thus: if you need synchronization, it is always about *more* than one thread. And of course, then you need to lock on something that **all** those threads have access to.

Or in other words: there is no point in **you** locking the door in order to prevent **yourself** from entering the building. 

But, as the other answer points out: it actually depends on the definition of "local" variable. Lets say you have:

```
void foo() {
  final Object lock = new Object();
  Thread a = new Thread() { uses lock
  Thread b = new Thread() { uses lock

```

then sure, that "local" variable can be used as lock for those two threads. And beyond that: that example works because synchronization happens on the **monitor** of a specific object. And objects reside on the heap. All of them.