217

在 Java 8 中，我可以轻松编写：

interface Interface1 {
    default void method1() {
        synchronized (this) {
            // Something
        }
    }

    static void method2() {
        synchronized (Interface1.class) {
            // Something
        }
    }
}

我将获得我也可以在类中使用的完整同步语义。但是，我不能synchronized在方法声明中使用修饰符：

interface Interface2 {
    default synchronized void method1() {
        //  ^^^^^^^^^^^^ Modifier 'synchronized' not allowed here
    }

    static synchronized void method2() {
        // ^^^^^^^^^^^^ Modifier 'synchronized' not allowed here
    }
}

现在，人们可以争辩说，这两个接口的行为方式相同，只是在 on和 on 上Interface2建立了一个合同，这比什么强一点。当然，我们也可能会争辩说，实现不应该对具体的实现状态做出任何假设，或者这样的关键字根本不会发挥作用。method1()method2()Interface1default

问题：

JSR-335 专家组决定不支持synchronized接口方法的原因是什么？

4

2 回答 2

270

虽然一开始似乎很明显人们希望支持synchronized默认方法的修饰符，但事实证明这样做很危险，因此被禁止。

同步方法是一种方法的简写，其行为就像整个主体都包含在一个synchronized块中，其锁定对象是接收者。将这种语义扩展到默认方法似乎也是明智的；毕竟，它们也是带有接收器的实例方法。（请注意，synchronized方法完全是句法优化；它们不是必需的，它们只是比相应的synchronized块更紧凑。有一个合理的论点可以说这首先是过早的句法优化，并且同步方法造成的问题多于解决的问题，但那艘船很久以前就航行了。）

那么，为什么它们很危险？同步是关于锁定的。锁定是关于协调对可变状态的共享访问。每个对象都应该有一个同步策略来确定哪些锁保护哪些状态变量。（请参阅Java 并发实践，第 2.4 节。）

许多对象使用Java 监视器模式(JCiP 4.1) 作为它们的同步策略，其中对象的状态由其内在锁保护。这种模式没有什么神奇或特别之处，但它很方便，并且synchronized在方法上使用关键字隐含地假定了这种模式。

拥有状态的类可以确定该对象的同步策略。但是接口不拥有它们所混入的对象的状态。因此，在接口中使用同步方法假定了一个特定的同步策略，但是你没有合理的假设基础，所以很可能是这样的情况同步的使用不会提供任何额外的线程安全性（您可能在错误的锁上同步）。这会给你一种错误的自信感，认为你已经做了一些关于线程安全的事情，并且没有错误消息告诉你你假设了错误的同步策略。

一致地维护单个源文件的同步策略已经足够困难了；更难确保子类正确遵守其超类定义的同步策略。试图在这种松散耦合的类（一个接口和可能实现它的许多类）之间这样做几乎是不可能的并且非常容易出错。

鉴于所有这些反对的论点，论据是什么？似乎它们主要是关于使接口的行为更像特征。虽然这是一个可以理解的愿望，但默认方法的设计中心是接口演变，而不是“Traits--”。在两者可以始终如一地实现的情况下，我们努力做到这一点，但在一个与另一个发生冲突的情况下，我们必须选择有利于主要设计目标。

于 2014-05-05T00:50:29.813 回答
0 
public class ParentSync {

public synchronized void parentStart() {
    System.out.println("I am " + this.getClass() + " . parentStarting. now:" + nowStr());
    try {
        Thread.sleep(30000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("I am " + this.getClass() + " . parentFinished. now" + nowStr());
}

private String nowStr() {
    return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
}
}


public class SonSync1 extends ParentSync {
public void sonStart() {
    System.out.println("I am " + this.getClass() + ". sonStarting,calling parent now ... ");
    super.parentStart();
    System.out.println("I am " + this.getClass() + ". sonFinished");
}
}



public class SonSync2 extends ParentSync {

public void sonStart() {
    System.out.println("I am " + this.getClass() + ". sonStarting,calling parent now ... ");
    super.parentStart();
    System.out.println("I am " + this.getClass() + ". sonFinished");
}
}



public class SyncTest {
public static void main(String[] args) throws Exception {

    new Thread(() -> {
        new SonSync1().sonStart();
    }).start();

    new Thread(() -> {
        new SonSync2().sonStart();
    }).start();

    System.in.read();
}
}

结果：

I am class com.common.interface18_design.whynotsync_onmethod.SonSync1. sonStarting,calling parent now ... 
I am class com.common.interface18_design.whynotsync_onmethod.SonSync2. sonStarting,calling parent now ... 
I am class com.common.interface18_design.whynotsync_onmethod.SonSync2 . parentStarting. now:2019-04-18 09:50:08
I am class com.common.interface18_design.whynotsync_onmethod.SonSync1 . parentStarting. now:2019-04-18 09:50:08
I am class com.common.interface18_design.whynotsync_onmethod.SonSync1 . parentFinished. now2019-04-18 09:50:38
I am class com.common.interface18_design.whynotsync_onmethod.SonSync1. sonFinished
I am class com.common.interface18_design.whynotsync_onmethod.SonSync2 . parentFinished. now2019-04-18 09:50:38
I am class com.common.interface18_design.whynotsync_onmethod.SonSync2. sonFinished

（抱歉以父类为例）

由结果可知，父类锁为每个子类所拥有，SonSync1 和 SonSync2 对象拥有不同的对象锁。每个锁都是独立的。所以在这种情况下，我认为在父类或公共接口中使用同步并不危险。有人可以对此进行更多解释吗？

于 2019-04-18T01:59:03.903 回答