同步关键字-如何运作？

Question

If I have a class, call it X and X contains a collection (assume I am not using one of the synchronized colections, just a normal one).

If I was to write my own method synchronized add()- how does the locking work? Is the locking done on the instance of X, and not on the collection object?

So synchronizing my add() method would not stop many instances of X from calling add() and inserting into the collection- therefore I could still have threading problems?

Answer 1

A synchronized method locks the object. If your X.add is synchronized, it will prevent concurrent execution of other synchronized methods of the same X object. If anyone out of that X object has access to the same collection, the collection will not be protected.

If you want your collection to be protected, make sure it is not accessible to the rest of the world in any way other than a synchronized method of X . Also, this is a bit unclear in your question, but note that a synchronized non-static method locks the object . Assuming each X instance will have a collection of its own, they won't interfere with each other.

Another option, BTW, is to lock the collection instead of the X object:

void add(Object o) {
   synchronized(myCollection) {
      myCollection.add(o);
   }
}

This will synchronize access to the locked collection instead of the X object. Use whichever you find easier and more effective.

Answer 2

In your example, synchronized will make sure only one thread can invoke the method on one instance of the class at a time. Other methods could access that collection, which would not be safe. Look up concurrent collections for more information on thread-safe collection implementations.

Answer 3

If I was to write my own method synchronized add()- how does the locking work? Is the locking done on the instance of X, and not on the collection object?

The locking is done on the object that you synchronized on -- not any fields within the object. For locking to work, all of the threads must synchronize on the same exact object. Typically a private final object is best to be locked on.

    private final Collection<...> myCollection = ...
    ...
    synchronize (myCollection) {
        myCollection.add(...);
    }

Although a common pattern is to lock on the object that you are protecting, it really can be any constant object. You could also do:

    private final Object lockObject = new Object();
    ...
    synchronize (lockObject) {
        myCollection.add(...);
    }

So synchronizing my add() method would not stop many instances of X from calling add() and inserting into the collection- therefore I could still have threading problems?

If other parts of your application are accessing the myCollection without being inside of a synchronized (myCollection) block, then yes, you are going to have threading problems. You would need to synchronize around all accesses to properly protect the collection and provide a memory barrier. That means add(...) , contains(...) , iterators, etc..

Often, if you are trying to protect a collection or other class, it makes sense to wrap it in a class which does the synchronization. This hides the locking and protects the collection from unintended modifications from code that is missing a synchronized block.

Answer 4

Is it true that you are sharing one collection across many X instances ? Then you need to synchronize on the collection instance itself. Don't make the method itself synchronized , but wrap all its code in a synchronized(coll) { ... } block.

If, on the other hand, each X has its own collection, then synchronized add() is all you need. This will guarantee that no two threads are executing add on the same instance at the same time.