You are right, and its easy to verify.
Just create a simple counter POJO with a single int field and an unsynchronized getter/setter pair. Create two runnable implementations. One that, in an infinite loop, simply gets and displays the counter value along with the name of the current thread, increments the counter and then goes to sleep for any number of milliseconds (using Thread.sleep(), as it doesn't mess with any locks). And another implementation that does the same thing, but synchronizes the entire run() method on the intrinsic lock of the POJO instance. Then create and start two Thread instances. First two that use the synchronized Runnable implementation, followed by another run that mixes them up.
You should notice that in the first run the thread that first aquires the lock of the POJO instance will be the only one doing the displaying/incrementing, because the other thread will be blocked and unable to obtain the lock. In the second run, while the synchonized implementation will still hold the POJO's lock forever, the other thread won't be blocked by it, because it never attempts to obtain the lock. You should see both threds happily displaying and incrementing the counter - albeit probably inconsistently.