锁定为实体成员与同步（最佳实践）

Question

Let's say I have an EntityPool. After I get an entity from the pool, I need to modify the entity in a thread-safe way. So I see 2 choices:

1) Using synchronized:

Entity e = pool.getById(id); 
synchronized (e) {
    // modifying e
}

2) Add a lock to the Entity class and use it:

Entity e = pool.getById(id);
Lock l = e.getLock();
try {
    l.lock();
    // modifying e
} finally {
    l.unlock();
}

I've heard that I should avoid using "synchronized" keyword. Should I use lock instead? But it seems weird to me that the Entity class should know anything about synchronization.

Answer 1

There are different use cases to justify both approaches.

1 is common. It uses the object itself as a lock, so any synchronized methods on the entity as well as any other synchronized access are serialized. It also does not require making the Entity class lock-aware.

2 requires that you embed a lock into the entity class. This allows you to control synchronization in a more fine-grained manner. You can, for instance, use the lock to control access to a subset of the object state while keeping methods accessing other parts of the object lock-free.

If you know what you're doing, there's no need to avoid the synchronized keyword. That can be said for locks as well.

Answer 2

Use 'synchronized' if your usage follows lexical scope. Synchronization starts when you enter a synchronized method or the body of a synchronized {…} clause, and ends when you leave it.

By contrast, locking and unlocking can be applied to arbitrary sequences of actions. You can, for example, acquire the lock in a call to some sort of 'startSomething' method, and release the lock in a later call to an 'endSomething' method. The cost of this is your need to ensure correctness.

tl;dr - use synchronized unless it clearly doesn't work for your use case.