Java中的同步方法和同步块有什么区别？

Question

Java 中的同步方法和同步块有什么区别？

我一直在网上搜索答案，人们似乎对此非常不确定:-(

我的看法是两者之间没有区别，除了同步块的范围可能更本地化，因此锁将时间更短？

如果对静态方法加锁，那么对类加锁的含义是什么？

Answer 1

同步方法使用方法接收器作为锁（即非静态方法的 this 和静态方法的封闭类）。 Synchronized 块使用表达式作为锁。

因此，从锁定的角度来看，以下两种方法是等效的：

synchronized void mymethod() { ... }

void mymethod() {
  synchronized (this) { ... }
}

对于静态方法，类将被锁定：

class MyClass {
  synchronized static mystatic() { ... }

  static mystaticeq() {
    syncrhonized (MyClass.class) { ... }
  }
}

对于同步块，您可以使用任何非null对象作为锁：

synchronized (mymap) {
  mymap.put(..., ...);
}

锁定范围< /b>

对于同步方法，锁将在整个方法范围内保持，而在 synchronized 块中，锁仅在该块范围内（也称为临界区）保持。 在实践中，如果 JVM 能够证明可以安全地完成，则允许通过从同步块执行中删除一些操作来进行优化。

Answer 2

同步方法是简写。 从所有意图和目的来看，这

class Something {
    public synchronized void doSomething() {
        ...
    }

    public static synchronized void doSomethingStatic() {
        ...
    }
}

相当于：（

class Something {
    public void doSomething() {
        synchronized(this) {
            ...
        }
    }

    public static void doSomethingStatic() {
        synchronized(Something.class) {
            ...
        }
    }
}

其中 Something.class 是类 Something 的类对象。）

确实如此，使用同步块，您可以更具体地了解您的锁，并更详细地了解何时要使用它，但除此之外没有任何区别。

Answer 3

是的，这是一个区别。 另一个是您可以获取除 this 之外的其他对象的锁。

Answer 4

关键区别在于：如果您声明一个方法要同步，那么该方法的整个主体都会变为同步； 但是，如果使用同步块，则可以仅将方法的“关键部分”包围在同步块中，而将方法的其余部分保留在块之外。

如果整个方法是关键部分的一部分，那么实际上没有区别。 如果情况并非如此，那么您应该仅在关键部分周围使用同步块。 同步块中的语句越多，获得的整体并行性就越少，因此您希望将这些语句保持在最低限度。

Answer 5

同步方法锁定该方法所在的对象实例。

同步块可以锁定任何对象 - 通常是定义为实例变量的互斥对象。 这可以更好地控制正在运行的锁。

Answer 6

我的看法是，两者之间没有区别，只是同步块的范围可能更本地化，因此锁定的时间会更短？？

是的。 你是对的。 与synchronized 方法不同，synchronized 语句必须指定提供内在锁的对象。

java 教程中的示例：

public void addName(String name) {
    synchronized(this) {
        lastName = name;
        nameCount++;
    }
    nameList.add(name);
}

同步语句对于通过细粒度同步提高并发性也很有用。 您可以在同一教程页面上找到以下用例的好示例。

例如，假设类 MsLunch 有两个实例字段 c1 和 c2，它们从不一起使用。 这些字段的所有更新都必须同步，但是没有理由阻止 c1 的更新与 c2 的更新交错 — 这样做会通过创建不必要的阻塞来减少并发性。 我们不使用同步方法或以其他方式使用与此相关的锁，而是创建两个对象来提供锁。

如果对静态方法进行锁定，那么锁定的对象是什么？ 类锁定是什么意思？

在这种情况下，线程获取与该类关联的 Class 对象的固有锁。 因此，对类的静态字段的访问是由与该类的任何实例的锁不同的锁控制的。

当您将方法设置为 同步 （非 static ) ：

同一对象上的两次同步方法调用不可能交错。 当一个线程正在执行对象的同步方法时，调用同一对象的同步方法的所有其他线程都会阻塞（挂起执行），直到第一个线程完成该对象。

如果将方法设置为静态同步方法：

同一类的不同对象上的静态同步方法的两次调用不可能交错。 当一个线程正在为 A 类对象执行静态同步方法时，所有其他对 A 类对象调用静态同步方法的线程都会阻塞（暂停执行）直到第一个线程完成方法执行。

您可以在此SE问题中找到同步的更好替代方案：

避免在Java中同步(this)？< /a>