Java thread synchronized block

Question

i am still a noob comes to thread and synchronized.
i heard people said that i shouldn't synchronized on "mySet" because "mySet" is getting modified in the synchronized block.
is this true?
or should i use a different object to synchronized the block. what's the advantage or disadvantage to use a different object to synchronized the block.
thanks
public class Test {
  final Set mySet = new HashSet(); 
  final Map myMap = new HashMap();
  public void add(Object o) {
    synchronize(mySet) {
      mySet.add(o);
      myMap.add(o);
  public void clear(){
    synchronize(mySet) {
      mySet.clear();
      myMap.clear();
}

Answer 1

yaliu07 wrote:
i am still a noob comes to thread and synchronized.
i heard people said that i shouldn't synchronized on "mySet" because "mySet" is getting modified in the synchronized block.
is this true? No, that's not a reason not to sync on that object. In fact, in some cases it's a reason why you should sync on that object.
Most of the time it doesn't matter which object you sync on, as long as all the relevant blocks are synced on the same object. There are a couple of considerations to keep in mind though that might affect the choice of object.
In some cases, you want to sync on an object that's not exposed to the outside world, for instance a private Object member variable that exists only to be a lock. The reason for this is that if you sync on something that's exposed to the outside (such as "this", which is what gets synced on when you declare a non-static method as synchronized), then other code might also sync on that object, causing deadlock or thread starvation.
In other cases, you DO want to expose the object, so that you can use it to ensure that other code and your synced code only enter the critical sections one thread at a time. For instance, in Collections.synchronizedXxx() methods, the return object's methods are all synced on "this", and any code that iterates over that collection must also sync on that object, so that the iteration code and the collection object's own code don't step on each other's toes.
Much of the time, however, the choice of an object to sync on is just one that's convenient and logical for the humans writing and reading the code.