quand utiliser une fonction inline dans Kotlin?

Je sais qu'une fonction inline va peut-être améliorer les performances & cause le code généré pour grandir, mais je ne suis pas sûr que lorsqu'il est correctement l'utiliser.

lock(l) { foo() }

Au lieu de créer un objet de fonction pour le paramètre et la génération d'un appel, le compilateur pourrait émettre le code suivant. (Source)

l.lock()
try {
  foo()
}
finally {
  l.unlock()
}

mais j'ai trouvé qu'il n'y a pas de fonction d'objet créé par kotlin, pour un non-fonction inline. pourquoi?

/**non-inline function**/
fun lock(lock: Lock, block: () -> Unit) {
    lock.lock();
    try {
        block();
    } finally {
        lock.unlock();
    }
}
  • Il existe deux principaux cas d'utilisation pour cela, on est avec certains types de fonctions supérieures, et l'autre est réifiée des paramètres de type. La documentation des fonctions inline couvre-ci: kotlinlang.org/docs/reference/inline-functions.html
  • merci, monsieur. mais je ne comprends pas que : "au Lieu de créer un objet de fonction pour le paramètre et la génération d'un appel, le compilateur pourrait émettre le code suivant"
  • je n'obtiens que l'exemple soit tbh.
InformationsquelleAutor holi-java | 2017-06-10
  1. 199

    Disons que vous créez un ordre supérieur de la fonction qui prend un lambda de type () -> Unit (pas de paramètres, pas de valeur de retour), et l'exécute comme suit:

    fun nonInlined(block: () -> Unit) {
    println("before")
    block()
    println("after")
}

    Dans le langage Java, cela permettra de passer à quelque chose comme ceci (simplifié!):

    public void nonInlined(Function block) {
    System.out.println("before");
    block.invoke();
    System.out.println("after");
}

    Et quand vous l'appelez de Kotlin...

    nonInlined {
    println("do something here")
}

    Sous le capot, une instance de Function seront créés ici, qui encapsule le code à l'intérieur de la lambda (encore une fois, c'est simplifié):

    nonInlined(new Function() {
    @Override
    public void invoke() {
        System.out.println("do something here");
    }
});

    Donc, fondamentalement, à l'appel de cette fonction, et en passant une lambda pourra toujours créer une instance d'un Function objet.

    D'autre part, si vous utilisez le inline mot-clé:

    inline fun inlined(block: () -> Unit) {
    println("before")
    block()
    println("after")
}

    Quand vous l'appelez comme ceci:

    inlined {
    println("do something here")
}

    Pas Function instance sera créée, au lieu de cela, le code autour de l'invocation de block à l'intérieur de la fonction inline seront copiés sur le site d'appel, de sorte que vous obtiendrez quelque chose comme ceci dans le bytecode:

    System.out.println("before");
System.out.println("do something here");
System.out.println("after");

    Dans ce cas, pas de nouvelles instances sont créées.

    • Quel est l'avantage d'avoir la Fonction de l'objet wrapper en premier lieu? ie - pourquoi n'est pas tout inline?
    • De cette façon, vous pouvez aussi arbitrairement passer des fonctions comme paramètres, de les stocker dans des variables, etc.
    • Grande explication par @zsmb13
    • mais vous pouvez aussi passer inline plaisir à l'autre inline amusant comme paramètre?
    • il ressemble à compilateur est ok avec le passage inline plaisir à l'autre inline plaisir
    • Vous pouvez, et si vous faites les choses compliquées avec eux, vous allez finalement vous voulez savoir à propos de la noinline et crossinline des mots - clés, voir la docs.
    • Les docs donner une raison vous ne voulez pas inline par défaut: Inline peut provoquer le code généré de la croissance; toutefois, si nous le faisons, d'une manière raisonnable (c'est à dire en évitant d'inlining grandes fonctions), il va payer à la performance, en particulier au "megamorphic" appelez-sites à l'intérieur des boucles.
    • Génial explication zsmb13. J'ai vérifié quelques endroits, mais n'a pas été en mesure de comprendre correctement. Merci pour ce partage...
    • Mais vous n'avez pas la réponse à la question "Quand les utiliser". Vous avez juste a expliqué comment il est utilisé. La réponse est dans les docs et indique que si vous avez une fonction avec une petite quantité de code et la fonction est beaucoup utilisé, puis à l'aide d'une fonction en ligne peut augmenter les performances.
    • Cette explication devrait être dans la documentation officielle. Merci

    InformationsquelleAutor zsmb13
  2. 11

    Permettez-moi d'ajouter: "Quand ne pas utiliser inline":

    1) Si vous disposez d'une simple fonction qui n'acceptent pas d'autres fonctions comme un argument, il ne fait pas de sens pour inline eux. IntelliJ vous préviens:

    Attendu d'impact sur les performances de l'in-lining '...' est insignifiant.
    Inline qui fonctionne le mieux pour les fonctions avec des paramètres de types fonctionnels

    2) Même si vous avez une fonction "avec des paramètres de types fonctionnels", vous risquez de rencontrer le compilateur vous dire que l'in-lining ne fonctionne pas. Considérons cet exemple:

    inline fun calculateNoInline(param: Int, operation: IntMapper): Int {
    val o = operation //compiler does not like this
    return o(param)
}

    Ce code ne compile pas avec l'erreur:

    Utilisation illégale de inline-paramètre 'opération' à '...'. Ajouter "noinline' modificateur à la déclaration de paramètre.

    La raison en est que le compilateur n'est pas en mesure de l'inclure ce code. Si operation n'est pas encapsulée dans un objet (qui est implicite par inline puisque vous ne voulez pas que cela), comment peut-il être affecté à une variable à tous? Dans ce cas, le compilateur suggère l'argument noinline. Avoir un inline fonction avec un seul noinline fonction n'a aucun sens, ne pas le faire. Cependant, s'il y a plusieurs paramètres de types fonctionnels, considérer l'in-lining certains d'entre eux, si nécessaire.

    Voici donc quelques règles suggérées:

    • Vous peut en ligne lorsque fonctionnel type de param est appelé directement ou transmis à autres inline fonction
    • Vous devrait en ligne lorsque ^ est le cas.
    • Vous ne peut pas en ligne lorsque les paramètres de la fonction est assignée à la variable à l'intérieur de la fonction
    • Vous devrait envisager l'in-lining, si au moins l'un de vos fonctionnelle tapé les paramètres peuvent être intégrées en utilisation noinline pour le reste.
    • Vous ne devrait pas inline énorme fonctions, pensez généré en byte code. Il sera copié dans tous les endroits où la fonction est appelée depuis.
    • Un autre cas d'utilisation est reified paramètres de type, qui vous obligent à utiliser inline. Lire ici.
    • merci pour votre réponse tardive, je l'ai!
    InformationsquelleAutor s1m0nw1
  3. 1

    Le plus important cas lorsque nous utilisons inline modificateur est lorsque nous définissons util-comme des fonctions avec des paramètres des fonctions. De la collecte ou du traitement de chaîne (comme filter, map ou joinToString) ou juste autonome les fonctions sont l'exemple parfait.

    C'est pourquoi inline modificateur est surtout une importante optimisation pour les développeurs de la bibliothèque. Ils doivent savoir comment ça fonctionne et quels sont ses améliorations et des coûts. Nous allons utiliser inline modificateur dans nos projets quand nous définissons notre propre util fonctions avec la fonction des paramètres de type.

    Lorsque nous n'avons pas de fonction de type de paramètre, réifiée paramètre de type, et nous n'avons pas besoin de non-retour locale, puis nous avons le plus probable ne devriez pas utiliser inline modificateur. C'est pourquoi nous allons avoir un avertissement sur Android Studio ou l'IDÉE d'IntelliJ.

    Il y a aussi le code de la taille du problème. Inline une grande fonction pourrait augmenter considérablement la taille du bytecode parce que c'est copié à tous les appels site. Dans de tels cas, vous pouvez restructurer la fonction et l'extrait de code pour des fonctions classiques.

    InformationsquelleAutor 0xAliHn