Accélération de la construction du studio Android Gradle


163

Depuis la dernière mise à jour (Build du 25 juin), tout changement dans le studio Android Gradle est douloureusement lent. Et il semble également effectuer un suivi automatique des modifications lorsque vous modifiez le fichier et recompilez lors de la saisie.

Chaque changement prend plusieurs minutes sur mon i5.

Une idée de la façon dont je peux accélérer mes modifications Gradle?



1
Pour ceux qui prennent le temps de lire la réponse et la question, ce n'est pas une question en double, comme le suggère @Dave Jarvis. Mais il est étroitement lié à une ancienne version bêta d'AS et n'a probablement que peu ou pas d'incidence sur les versions actuelles.
Einar Sundgren


Réponses:


41

Les développeurs y travaillent. Comme je l'ai signalé dans cette réponse, la solution la plus rapide pour le moment est d'utiliser gradle à partir de la ligne de commande et vous devriez passer aux bibliothèques binaires pour tous les modules que vous ne développez pas. Sur g +, il y a une discussion avec les développeurs à ce sujet.


J'aurais évidemment dû rejoindre le groupe de discussion sur l'outil plus tôt.
Einar Sundgren

99

Fait vraiment une différence: Comment… accélérer le temps de création de Gradle

Créez simplement un fichier nommé gradle.propertiesdans le répertoire suivant:

/home/<username>/.gradle/ (Linux)
/Users/<username>/.gradle/ (Mac)
C:\Users\<username>\.gradle (Windows)

Ajoutez cette ligne au fichier:

org.gradle.daemon=true

2
Bonne réponse. Pour une lecture plus approfondie et détaillée, consultez cette réponse SO.
Sufian

12
À partir de votre lien: "Remarque: cela n'affecte que les versions de la console. Android Studio utilise toujours un démon Gradle (et en fonction de vos paramètres, d'autres optimisations)."
ChiefTwoPencils

2
J'ai .gradle répertoire avec gradle.properties fichier. Mais cela prend encore beaucoup de temps. Toute suggestion
CoDe

4
Ça ne fait aucune différence
Vlado Pandžić

Et redémarrez Android Studio après avoir effectué la modification.
Iman Marashi

78

Après avoir modifié ces paramètres, mon temps de compilation de 10 minutes a été réduit à 10 secondes.

Étape 1:

Paramètres (ctrl + Alt + S) ->

Construction, exécution, déploiement ->

Compilateur ->

tapez " --offline" dans la zone Options de la ligne de commande.

Étape 2:

cochez la case «Compiler les modules indépendants en parallèle».

& cliquez sur Appliquer -> OK

entrez la description de l'image ici

Étape 3: Dans votre fichier gradle.properties -> Ajouter les lignes suivantes

org.gradle.jvmargs=-Xmx2048M -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
org.gradle.parallel=true
org.gradle.configureondemand=true
org.gradle.daemon=true

Mettre à jour:

Si vous utilisez Android Studio 2.0 ou supérieur, essayez Instant Run

Paramètres → Construction, exécution, déploiement → Exécution instantanée → Activer l'exécution instantanée.

Plus d'informations sur Instant Run - https://developer.android.com/studio/run/index.html#instant-run


6
J'ai essayé cela et cela accélère considérablement ma construction. Je sais que l'option le fera désormais construire hors ligne, y a-t-il des inconvénients à le construire hors ligne?
Simon

5
@Simon - L'inconvénient est que vous ne pourrez pas extraire les dernières versions des dépendances identifiées dans votre fichier build.gradle. Il fonctionne plus rapidement car il utilise un instantané mis en cache de ces bibliothèques importées. Pour certains développeurs, la stabilité est primordiale, mais une mise hors ligne trop longue peut les gâcher quand ils se mettent enfin en ligne et ces dépendances ont évolué, laissant ainsi ledit projet derrière.
Mark Lapasa le

1
Merci mon frère, celui-ci a bien fonctionné pour moi et ma vitesse de création graduelle est augmentée
Android_programmer_office

@Simon, lorsque vous commencez à développer, vous pouvez simplement définir les paramètres ci-dessus, puis une fois arrêter, les désactiver juste à la fin de la nuit, en exécutant l'application une dernière fois pour que tout soit toujours synchronisé. Ou y aurait-il un problème avec cela?
Sauron

1
il est passé de 33 secondes à 5 secondes :))
Miron

62

J'ai pu réduire ma compilation gradle de 43 secondes à 25 secondes sur mon ancien ordinateur portable core2duo (exécutant Linux mint) en ajoutant ce qui suit au fichier gradle.properties dans Android Studio

org.gradle.parallel=true
org.gradle.daemon=true

source expliquant pourquoi le paramètre de démon accélère les builds: https://www.timroes.de/2013/09/12/speed-up-gradle/


3
À partir de votre lien: "Remarque: cela n'affecte que les versions de la console. Android Studio utilise toujours un démon Gradle (et en fonction de vos paramètres, d'autres optimisations)."
ChiefTwoPencils

2
L'option parallèle a amélioré ma construction même en AS. Merci :)
jonathanrz

3
L'option parallèle n'a pas amélioré ma construction.
Vlado Pandžić

Merci. Cette solution a fait passer mon temps de construction de 7 minutes à 23 secondes ...
Vignesh Bala

merci fait ma construction de deux minutes à 3 secondes
Pouya Samie

12

Suivre les étapes le rendra 10 fois plus rapide et réduira le temps de construction de 90%

Créez d'abord un fichier nommé gradle.properties dans le répertoire suivant:

/home/<username>/.gradle/ (Linux)
/Users/<username>/.gradle/ (Mac)
C:\Users\<username>\.gradle (Windows)

Ajoutez cette ligne au fichier:

org.gradle.daemon=true
org.gradle.parallel=true

Et vérifiez ces options dans Android Studio

entrez la description de l'image ici

entrez la description de l'image ici


7

Il existe une version plus récente de gradle (ver 2.4).

Vous pouvez définir cela pour votre (vos) projet (s) en ouvrant la boîte de dialogue `` Structure du projet '' dans le menu Fichier,

Project Structure -> Project -> Gradle version

et réglez-le sur «2.4».
Vous pouvez en savoir plus sur l'amélioration des performances sur ce lien .


2
Merci, la version 2.4 de Gradle a enregistré près de 14 secondes.
Miao1007

5
Cela a allongé mon temps de construction
Egemen Hamutçu


6

C'est ce que j'ai fait et ma vitesse de construction gradle s'est considérablement améliorée! de 1 min à 20 s pour la première construction et les constructions suivantes sont passées de 40 s à 5 s.

Dans le fichier gradle.properties , ajoutez ceci:

org.gradle.jvmargs=-Xmx8192M -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8

Dans les arguments de la ligne de commande via Allez dans Fichier> Autres paramètres> Paramètres par défaut> Construire, exécuter, déployer> Complier et ajoutez les arguments suivants aux arguments de ligne de commande

Ajoute ça:

--debug --stacktrace -a, --no-rebuild -q, --quiet --offline

Voir l'image ici


6

Essayez d'éviter d'utiliser un Mac / PC qui n'a que 8 Go de RAM lors du développement Android. Dès que vous lancez ne serait-ce qu'un émulateur (Genymotion ou autre), vos temps de build deviennent extrêmement lents dans Android Studio avec des builds gradle. Cela se produit même si vous apportez une simple modification d'une ligne à 1 fichier source.

Fermer l'émulateur et utiliser un appareil réel aide beaucoup, mais bien sûr, c'est très limitant et moins flexible. Réduire le paramètre d'utilisation de la RAM de l'émulateur peut aider, mais le meilleur moyen est de s'assurer que votre ordinateur portable dispose d'au moins 12 à 16 Go de RAM.

Mise à jour (juin 2017): Il existe maintenant plusieurs bons articles de medium.com qui expliquent en détail comment accélérer les builds de gradle d'Android Studio, et cela fonctionne même sur des machines de 8 Go:

Le consensus résumé est:

Créez un fichier gradle.properties (global à ~/.gradle/gradle.propertiesou local au projet) et ajoutez les lignes suivantes:

org.gradle.daemon=true
org.gradle.jvmargs=-Xmx2048m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
org.gradle.parallel=true
org.gradle.configureondemand=true

4
  1. Activer le travail hors ligne

  2. Améliorez les performances de Gradle en ajoutant le code suivant dans gradle.properties

org.gradle.daemon = vrai
org.gradle.parallel = vrai

Guide étape par étape: http://www.viralandroid.com/2015/08/how-to-make-android-studio-fast.html


Gardons ces réponses variées et concentrons-nous sur les détails de la question OP. re: stackoverflow.com/a/34828203 ... stackoverflow.com/a/34827929 ... stackoverflow.com/a/34827858 ... stackoverflow.com/a/34827827 ... stackoverflow.com/a/34827788
Drew


3

Selon cette page de l' équipe Android des applications Wikimedia , un bon moyen d'optimiser les versions Gradle est d'ajouter ces lignes à votre ~ / .gradle / gradle.properties

org.gradle.daemon=true                                                          
org.gradle.parallel=true
org.gradle.configureondemand=true
org.gradle.jvmargs=-Xmx2048M

Pour ceux qui n'ont pas le fichier, il y a deux façons de le faire:

  1. Ajoutez le fichier localement dans votre projet en créant un fichier appelé gradle.properties à la racine du projet ou,

  2. Vous pouvez les définir globalement pour tous vos projets en créant le même fichier dans votre répertoire personnel (% UserProfile% .gradle sous Windows , ~ / .gradle sous Linux et Mac OS X )

    Il est recommandé de définir les propriétés dans votre répertoire personnel, plutôt qu'au niveau du projet.


2

Vous pouvez également utiliser la ligne de commande pour de meilleures performances.Vous pouvez utiliser la commande ./gradlew <task name>depuis le dossier racine de votre projet depuis Linux ou utiliser le fichier gradlew.bat comme gradlew<task name> vous exécutez pour la première fois l'une des commandes ci-dessus pour un Gradle donné version, il téléchargera la distribution Gradle correspondante et l'utilisera pour exécuter la construction.

Lors de l'importation d'un projet Gradle via son wrapper, votre IDE peut demander à utiliser la distribution Gradle 'all'. Cela convient parfaitement et aide l'EDI à compléter le code pour les fichiers de construction. Non seulement cela signifie que vous n'avez pas à installer manuellement Gradle vous-même, mais vous êtes également sûr d'utiliser la version de Gradle pour laquelle la version est conçue. Cela rend vos constructions historiques plus fiables. pour plus d'informations, reportez-vous à Exécution d'une compilation avec le Wrapper


2

Pour des versions plus rapides, augmentez la taille maximale du segment de mémoire pour le démon Gradle à plus de 2 048 Mo.

Pour ce faire, définissez
org.gradle.jvmargs=-Xmx2048M
dans le projet gradle.properties .


1

Ajouter un build.gradlefichier:

android {
...
dexOptions {
        javaMaxHeapSize "4g" //specify the heap size for the dex process
    }
...
}

J'espère que cela aide.


1

J'utilise un i7 de 5e génération avec Windows 10 et un SSD de 1 To. J'ai compressé le dossier Android Studio Projects et j'ai obtenu une augmentation d'environ 80%. J'espère que cela t'aides.

Je l'ai ensuite combiné avec les solutions ci-dessus, c'est-à-dire (org.gradle.parallel = true, org.gradle.daemon = true). L'amélioration des performances était assez impressionnante.

Aditionellement:

Toutes les réponses ci-dessus sont totalement correctes, mais je dois déclarer en tant que développeur Android d'expérience (de 4 ans et demi) que: Aucun développeur Android / Gradle ne devrait travailler sur une machine avec un lecteur spinner, vous devez débourser pour un État solide. Nous avons tous appuyé sur ce bouton de lecture dans l'IDE des centaines de fois par jour. Quand je suis passé d'un spinner à un SSD (post Gradle), ma vitesse et mon efficacité étaient littéralement 2 à 4 fois plus rapides et je vous promets que je n'exagère PAS ici.

Maintenant, je ne parle pas d'avoir une machine avec un petit SSD et un gros spinner, je parle d'un gros SSD. Si vous avez déjà une machine avec un petit SSD et un gros spinner, vous pouvez mettre à niveau le petit spinner pour dire un SSD de 500 Go et définir le SSD comme lecteur principal du système d'exploitation avec vos outils de développement installés dessus.

Donc, si vous travaillez dans un environnement au rythme rapide, veuillez montrer ce message à votre patron. Un SSD de 1 To décent vous coûtera environ 300 £ (TVA comprise), ou environ 160 £ pour un SSD de 500 Go. Selon que vous êtes un développeur Android junior ou senior, le lecteur se paiera de lui-même (en frais de salaires) en 1 à 2 semaines ouvrables, ou environ 2 jours et demi à 5 jours ouvrables si vous investissez dans un plus petit; disons un SSD de 500 Go.

Beaucoup de développeurs peuvent affirmer que ce n'est pas le cas, mais c'est le cas pour Gradle, car le système Gradle est très dur sur l'accès direct au disque. Si vous travaillez avec .NET / C # / VB Net ou d'autres outils de développement, vous ne remarquerez pas beaucoup de différence, mais la différence dans Gradle est ÉNORME. Si vous agissez sur ce post, je vous le promets, vous ne serez pas déçu. Personnellement, j'utilise un i7 de cinquième génération avec 8 Go de RAM qui était à l'origine livré avec un Spinner de 1 To et je l'ai mis à niveau vers un Samsung SSD 840 EVO 1 To et je n'ai jamais regardé en arrière depuis. J'ai acheté le mien sur: https://www.aria.co.uk .

J'espère que cela t'aides. Je dois également dire que ce n'est PAS un article à motivation commerciale, je recommande simplement Aria car je les ai utilisés plusieurs fois auparavant et ils ont toujours été fiables.


1

quelques commandes que nous pouvons ajouter au fichier gradle.properties:

org.gradle.configureondemand = true - Cette commande indiquera à gradle de ne construire que les projets dont il a vraiment besoin pour construire. Use Daemon - org.gradle.daemon = true - Daemon maintient l'instance du gradle en marche en arrière-plan même après la fin de la construction. Cela supprimera le temps nécessaire pour initialiser le gradle et réduira considérablement le temps de construction.

org.gradle.parallel = true - Autorise gradle à créer votre projet en parallèle. Si vous avez plusieurs modules dans votre projet, en activant cela, gradle peut exécuter des opérations de construction pour des modules indépendants en parallèle.

Augmenter la taille du tas - org.gradle.jvmargs = -Xmx3072m -XX: MaxPermSize = 512m -XX: + HeapDumpOnOutOfMemoryError -Dfile.encoding = UTF-8 - Depuis android studio 2.0, gradle utilise dex dans le processus pour réduire les délais de construction pour le projet. En général, lors de la création des applications, plusieurs processus dx s'exécutent sur différentes instances de VM. Mais à partir d'Android Studio 2.0, tous ces processus dx s'exécutent dans la seule VM et cette VM est également partagée avec le gradle. Cela réduit considérablement le temps de génération car tout le processus dex s'exécute sur les mêmes instances de VM. Mais cela nécessite une plus grande mémoire pour accueillir tous les processus dex et gradle. Cela signifie que vous devez augmenter la taille du tas requise par le démon gradle. Par défaut, la taille du tas du démon est d'environ 1 Go.

Assurez-vous que la dépendance dynamique n'est pas utilisée. c'est-à-dire ne pas utiliser l'implémentation «com.android.support:appcompat-v7:27.0.+». Cette commande signifie que gradle sera mis en ligne et vérifiera la dernière version à chaque fois qu'il crée l'application. Utilisez plutôt des versions fixes, c'est-à-dire «com.android.support:appcompat-v7:27.0.2»


1

Ajoutez ceci à votre gradle.propertiesfichier

org.gradle.daemon=true                                                          
org.gradle.parallel=true
org.gradle.configureondemand=true
org.gradle.jvmargs=-Xmx2048M

1

Ouvrez gradle.properties à partir du dossier Android et décommentez les lignes en surbrillance et fournissez les valeurs de mémoire selon la configuration de votre machine. J'ai 8 Go de RAM sur ma machine, donc j'ai donné un maximum de 4096 Mo et 1024 Mo respectivement.

# Specifies the JVM arguments used for the daemon process.
# The setting is particularly useful for tweaking memory settings.
# Default value: -Xmx10248m -XX:MaxPermSize=256m
//Uncomment below line for providing your system specific configuration
#org.gradle.jvmargs=-Xmx4096m -XX:MaxPermSize=1024m -XX:+HeapDumpOnOutOfMemoryError - Dfile.encoding=UTF-8

# When configured, Gradle will run in incubating parallel mode.
# This option should only be used with decoupled projects. More details, visit
#http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
 //Uncomment below line to allow parallel process execution.
 #org.gradle.parallel=true

Mon temps de construction a été réduit de moitié après cela. Bonne construction !!


0

Cela se produit souvent lorsque vous avez activé le multidex dans votre projet. Cela peut potentiellement ralentir votre processus de développement !! Selon doc :

La configuration multidex nécessite un temps de traitement de construction considérablement accru car le système de construction doit prendre des décisions complexes sur les classes à inclure dans le fichier DEX principal et les classes qui peuvent être incluses dans les fichiers DEX secondaires. Cela signifie que les générations incrémentielles utilisant le multidex prennent généralement plus de temps et peuvent potentiellement ralentir votre processus de développement.

mais vous pouvez optimiser ceci:

Pour réduire les temps de génération incrémentiels plus longs, vous devez utiliser le pré-dexing pour réutiliser la sortie multidex entre les générations.

Si vous utilisez Android Studio 2.3 et supérieur, l'EDI utilise automatiquement cette fonctionnalité lors du déploiement de votre application sur un appareil exécutant Android 5.0 (niveau d'API 21) ou supérieur.

Vous devez donc définir minSdkVersion sur 21 ou plus !

Mais si votre version de production doit prendre en charge minSdkVersion inférieure à 21, par exemple 19

vous pouvez utiliser productFlavors pour définir minSdkVersion 21 pour votre version de développement:

    android {
    defaultConfig {
        ...
        multiDexEnabled true
        // The default minimum API level you want to support.
        minSdkVersion 15
    }
    productFlavors {
        // Includes settings you want to keep only while developing your app.
        dev{
            //the IDE automatically uses  pre-dexing feature to mitigate longer incremental when deploying your app to a device running Android 5.0 !
            minSdkVersion 21
        }
        prod {

        }
    }
    buildTypes {
        release {
            minifyEnabled true
            proguardFiles getDefaultProguardFile('proguard-android.txt'),
                                                 'proguard-rules.pro'
        }
    }
}
dependencies {
    compile 'com.android.support:multidex:1.0.3'
}

0

Je préfère construire à partir de la ligne de commande pour de meilleurs temps de construction. Si la base de code de votre application est volumineuse et que vous avez plusieurs modules, vous pouvez essayer l'approche AAR locale comme décrit ici, cela vous donnera un gros coup de pouce dans les performances d'Android Studio et les temps de construction des gradins. Il est également compatible avec les versions de ligne de commande

https://blog.gojekengineering.com/how-we-improved-performance-and-build-times-in-android-studio-306028166b79

Le projet de démonstration avec les instructions d'intégration peut être trouvé ici: https://github.com/akhgupta/AndroidLocalMavenRepoAARDemo

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.