Perché i riferimenti al metodo non sono singleton?

Question

In Java, il codice seguente restituisce false in entrambe le query. Perché? Non sarebbe più semplice per i riferimenti al metodo essere singleton? Certamente renderebbe molto più semplice attaccare e staccare gli ascoltatori. Poiché è necessario mantenere una costante per qualsiasi riferimento al metodo che dovrà essere verificato in equivalenza, non è possibile utilizzare l'operatore di riferimento del metodo in ogni posizione necessaria.

public class Main { 

    public Main() { 
     // TODO Auto-generated constructor stub 
    } 

    public void doStuff() { 

    } 

    public static void main(String[] args) { 
     Main main = new Main(); 
     Runnable thing1 = main::doStuff; 
     Runnable thing2 = main::doStuff; 
     System.out.println(thing1 == thing2); // false 
     System.out.println(thing1.equals(thing2)); // false 
    } 

} 

Answer 1

Per esempio metodi, non credo che avrebbe senso per loro di essere memorizzati nella cache. Dovresti memorizzare nella cache un metodo per istanza ... il che significherebbe un campo aggiuntivo all'interno della classe associata al metodo: uno per metodo pubblico, presumibilmente, perché i metodi potrebbero essere referenziati da fuori della classe o memorizzati nella cache utente del riferimento al metodo, nel qual caso sarà necessaria una sorta di cache per istanza.

Penso che sia più sensato per i riferimenti al metodo metodi statici da memorizzare nella cache, perché saranno sempre gli stessi. Tuttavia, per memorizzare nella cache l'effettivo Runnable, avresti bisogno di una cache per tipo a cui puntava. Per esempio:

public interface NotRunnable { 
    void foo(); 
} 

Runnable thing1 = Main::doStuff; // After making doStuff static 
NotRunnable thing2 = Main::doStuff; 

caso thing1 e thing2 essere uguali qui? In che modo il compilatore saprebbe che tipo di creare, se sì? Potrebbe creare qui due istanze e memorizzarle in una cache separata - e sempre cache nel punto di utilizzo piuttosto che nel punto della dichiarazione del metodo. (Il vostro esempio ha la stessa classe di dichiarare il metodo e il riferimento a esso, che è un caso molto speciale. Si dovrebbe prendere in considerazione il caso più generale in cui sono diversi>)

Il JLS permette per il metodo di riferimenti a essere memorizzati nella cache . Da section 15.13.3:

successivo, sia una nuova istanza di una classe con le proprietà di seguito viene allocata e inizializzata, o un'istanza esistente di una classe con le proprietà di seguito viene fatto riferimento.

... ma anche per i metodi statici, sembra che javac non faccia alcun caching al momento.

Answer 2

In questo semplice caso, è possibile eseguire come suggerito creando campi statici o di istanze aggiuntivi come appropriato, più complesso se il lambda fa riferimento agli oggetti, tuttavia l'intento è quello di rendere invisibili tali istanze, ad es.

List<String> list = .... 
list.stream().filter(s -> !s.isEmpty()).forEach(System.out::println); 

dovrebbe essere il più efficiente (anche creare altri oggetti diversi)

for (String s : list) 
    if(!s.isEmpty()) 
     System.out.println(s); 

Può eliminare gli oggetti inlining il codice corrente e utilizzando l'analisi di fuga per eliminare la necessità di creare oggetti nella prima posto.

Per questo motivo si è prestata poca attenzione all'implementazione di equals(), hashCode() o toString(), accedendovi tramite riflessione per le chiusure. AFAIK, questo deliberato per evitare che gli oggetti vengano utilizzati in modi non previsti.

Answer 3

Per eseguire i singleton dei metodi è necessario sincronizzare l'acquisizione di un riferimento ad essi. Questo dà un grande overhead per un'operazione così semplice con risultati imprevedibili.L'altra soluzione consiste nel creare oggetti per ogni metodo sul caricamento della classe, ma ciò comporta molti oggetti ridondanti, poiché solo pochi metodi richiedono il riferimento. Penso che la sincronizzazione sia il problema principale.