每当在SO上出现关于Java同步的问题时，有些人都急于指出应该避免同步(这一点)。相反，他们声称，对私有引用的锁定是首选的。
其中一些原因是:
一些邪恶的代码可能会偷你的锁(这个很流行，也有一个“意外”变体)
同一类中的所有同步方法都使用完全相同的锁，这降低了吞吐量
你(不必要地)暴露了太多信息
包括我在内的其他人认为，synchronized(this)是一个被大量使用的习语(在Java库中也是如此)，是安全的，而且很容易理解。它不应该被避免，因为你有一个错误，你不知道你的多线程程序中发生了什么。换句话说:如果它是适用的，那么就使用它。
我感兴趣的是看到一些现实世界的例子(没有foobar的东西)，避免锁定在这是可取的，当同步(这)也会做的工作。
因此:您应该总是避免synchronized(this)，并将其替换为私有引用上的锁吗?
一些进一步的信息(随着答案的更新):
we are talking about instance synchronization
both implicit (synchronized methods) and explicit form of synchronized(this) are considered
if you quote Bloch or other authorities on the subject, don't leave out the parts you don't like (e.g. Effective Java, item on Thread Safety: Typically it is the lock on the instance itself, but there are exceptions.)
if you need granularity in your locking other than synchronized(this) provides, then synchronized(this) is not applicable so that's not the issue
我只想提到一种可能的解决方案，用于在没有依赖关系的原子代码部分中惟一的私有引用。您可以使用带锁的静态Hashmap和名为atomic()的简单静态方法，该方法使用堆栈信息(完整的类名和行号)自动创建所需的引用。然后，您可以在同步语句中使用此方法，而无需写入新的锁对象。
// Synchronization objects (locks)
private static HashMap<String, Object> locks = new HashMap<String, Object>();
// Simple method
private static Object atomic() {
StackTraceElement [] stack = Thread.currentThread().getStackTrace(); // get execution point
StackTraceElement exepoint = stack[2];
// creates unique key from class name and line number using execution point
String key = String.format("%s#%d", exepoint.getClassName(), exepoint.getLineNumber());
Object lock = locks.get(key); // use old or create new lock
if (lock == null) {
lock = new Object();
locks.put(key, lock);
}
return lock; // return reference to lock
}
// Synchronized code
void dosomething1() {
// start commands
synchronized (atomic()) {
// atomic commands 1
...
}
// other command
}
// Synchronized code
void dosomething2() {
// start commands
synchronized (atomic()) {
// atomic commands 2
...
}
// other command
}
在c#和Java阵营中似乎有不同的共识。我看到的大多数Java代码使用:
// apply mutex to this instance
synchronized(this) {
// do work here
}
而大多数c#代码选择了更安全的:
// instance level lock object
private readonly object _syncObj = new object();
...
// apply mutex to private instance level field (a System.Object usually)
lock(_syncObj)
{
// do work here
}
c#语言当然更安全。如前所述，不能从实例外部对锁进行恶意/意外访问。Java代码也有这种风险，但随着时间的推移，Java社区似乎倾向于稍微不那么安全，但稍微更简洁的版本。
这并不是对Java的挖苦，只是我在这两种语言上工作的经验的反映。
