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: 
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.
Yes, it does make sense when the local variable is used to synchronize access to a block of code from threads that are defined and created in the same method as the local variable.