Android Studio Gradle build acelerar

Desde la última actualización (compilación del 25 de junio), cualquier cambio en el estudio de Android Gradle es extremadamente lento. Y también parece realizar un seguimiento automático de los cambios cuando edita el archivo y se vuelve a compilar en el keyup.

Cada cambio lleva varios minutos en mi i5.

¿Alguna idea de cómo puedo acelerar mis cambios de Gradle?

Los desarrolladores están trabajando en eso. Como publiqué en esta respuesta, la solución más rápida en este momento es usar gradle desde la línea de comandos y debe cambiar a bibliotecas binarias para todos los módulos que no desarrolle. En g + hay una discusión con los desarrolladores al respecto.

Definitivamente hace la diferencia: cómo ... acelerar el tiempo de construcción de Gradle

Simplemente cree un archivo nombrado gradle.propertiesen el siguiente directorio:

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

Agregue esta línea al archivo:

org.gradle.daemon=true

Después de cambiar esta configuración, mi tiempo de compilación 10 minutos se redujo a 10 segundos.

Paso 1:

Configuración (ctrl + Alt + S) ->

Compilación, ejecución, implementación ->

Compilador ->

escriba " --offline" en el cuadro de opciones de la línea de comandos.

Paso 2:

marque la casilla de verificación "Compilar módulos independientes en paralelo".

y haga clic en Aplicar -> Aceptar

Paso 3: en su archivo gradle.properties -> Agregar líneas siguientes

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

Actualizar:

Si está utilizando Android Studio 2.0 o superior, pruebe la ejecución instantánea

Configuración → Compilación, Ejecución, Implementación → Ejecución instantánea → Habilitar ejecución instantánea.

Más información sobre Instant Run: https://developer.android.com/studio/run/index.html#instant-run

Pude reducir mi compilación de gradle de 43 segundos a 25 segundos en mi vieja computadora portátil core2duo (ejecutando linux mint) agregando lo siguiente al archivo gradle.properties en android studio

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

fuente sobre por qué la configuración del demonio hace que las compilaciones sean más rápidas: https://www.timroes.de/2013/09/12/speed-up-gradle/

Seguir los pasos lo hará 10 veces más rápido y reducirá el tiempo de construcción en un 90%

Primero cree un archivo llamado gradle.properties en el siguiente directorio:

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

Agregue esta línea al archivo:

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

Y verifica estas opciones en Android Studio

Hay una versión más nueva de gradle (ver 2.4).

Puede configurar esto para sus proyectos abriendo el cuadro de diálogo 'Estructura del proyecto' en el menú Archivo,

Project Structure -> Project -> Gradle version

y configúrelo en '2.4'.
Puede leer más sobre cómo aumentar el rendimiento en este enlace .

Con Android Studio 2.1 puede habilitar "Dex In Process" para compilaciones de aplicaciones más rápidas.

Puede obtener más información al respecto aquí: https://medium.com/google-developers/faster-android-studio-builds-with-dex-in-process-5988ed8aa37e#.vijksflyn

¡Esto es lo que hice y mi velocidad de construcción de gradle mejoró dramáticamente! de 1 minuto a 20 segundos para la primera construcción y las siguientes se convirtieron en 40 segundos a 5 segundos.

En el archivo gradle.properties , agregue esto:

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

En los Argumentos de la línea de comandos a través de Ir a Archivo> Otras configuraciones> Configuración predeterminada> Construir, Ejecutar, Implementar> Cumplidor y agregar los siguientes argumentos a los Argumentos de la línea de comandos

Agrega esto:

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

Intente evitar el uso de una Mac / PC que tenga solo 8 GB de RAM cuando realice el desarrollo de Android. Tan pronto como inicies incluso 1 emulador (Genymotion o no), tus tiempos de compilación se vuelven extremadamente lentos en Android Studio con compilaciones gradle. Esto sucede incluso si realiza un simple cambio de una línea a 1 archivo fuente.

Cerrar el emulador y usar un dispositivo real ayuda mucho, pero por supuesto esto es muy limitante y menos flexible. La reducción de la configuración de uso de RAM del emulador puede ayudar, pero la mejor manera es asegurarse de que su computadora portátil tenga al menos 12-16 GB de RAM.

Actualización (junio de 2017): ahora hay varios buenos artículos de medium.com que explican cómo acelerar las compilaciones de Android Studio Gradle en detalle, e incluso funciona en máquinas de 8 GB:

• Cómo disminuir el tiempo de construcción de Gradle en un 65% : https://medium.com/@kevalpatel2106/how-to-decrease-your-gradle-build-time-by-65-310b572b0c43
• ¡Haz que tu Gradle construya rápido de nuevo! : https://medium.com/@wasyl/make-your-gradle-builds-fast-again-ea323ce6a435

El consenso resumido es:

Cree un archivo gradle.properties (global en ~/.gradle/gradle.propertieso local para proyectar) y agregue las siguientes líneas:

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

1. Habilitar trabajo sin conexión

2. Mejore el rendimiento de Gradle agregando el siguiente código en gradle.properties

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

Guía paso a paso: http://www.viralandroid.com/2015/08/how-to-make-android-studio-fast.html

dexOptions {
    incremental true
    javaMaxHeapSize "4g"
}

Según esta página del equipo de aplicaciones de Wikimedia de Android , una buena forma de optimizar las compilaciones de Gradle es agregar estas líneas a sus ~ / .gradle / gradle.properties

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

Para aquellos que no tienen el archivo, hay dos formas de hacerlo:

1. Agregue el archivo localmente en su proyecto creando un archivo llamado gradle.properties en la raíz del proyecto o,

2. Puede configurarlos globalmente para todos sus proyectos creando el mismo archivo en su directorio de inicio (% UserProfile% .gradle en Windows , ~ / .gradle en Linux y Mac OS X )

   Es una buena práctica establecer las propiedades en su directorio de inicio, en lugar de en un nivel de proyecto.

También puede usar la línea de comandos para un mejor rendimiento. Puede usar el comando ./gradlew <task name>desde el interior de la carpeta raíz de su proyecto desde Linux o usar el archivo gradlew.bat como gradlew <task name>. Cuando ejecuta uno de los comandos anteriores para un Gradle dado versión, descargará la distribución Gradle correspondiente y la usará para ejecutar la compilación.

Al importar un proyecto de Gradle a través de su contenedor, su IDE puede pedirle que use la distribución 'todos' de Gradle. Esto está perfectamente bien y ayuda al IDE a proporcionar la finalización del código para los archivos de compilación. Esto no solo significa que no tiene que instalar Gradle manualmente, sino que también está seguro de usar la versión de Gradle para la que está diseñada la compilación. Esto hace que sus compilaciones históricas sean más confiables. para obtener más información, consulte Ejecutar una compilación con el Wrapper

Para compilaciones más rápidas, aumente el tamaño de almacenamiento dinámico máximo para el demonio Gradle a más de 2048 MB.

Para ello, establezca
org.gradle.jvmargs=-Xmx2048M
en el proyecto gradle.properties .

Agrega un build.gradlearchivo:

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

Espero que ayude.

Estoy ejecutando un i7 de quinta generación con Windows 10 y un estado sólido de 1 TB. Comprimí la carpeta de Proyectos de Android Studio y obtuve un aumento del 80%. Espero que esto ayude.

Luego lo combiné con las soluciones anteriores, es decir (org.gradle.parallel = true, org.gradle.daemon = true). El aumento de rendimiento fue bastante impresionante.

Adicionalmente:

Todas las respuestas anteriores son totalmente correctas, pero debo decir como un desarrollador de Android con experiencia (de 4 años y medio) que: Ningún desarrollador de Android / Gradle debería estar trabajando en una máquina con un disco giratorio, debe desembolsar un De Estado sólido. Todos presionamos ese botón de reproducción en el IDE 100 veces al día. Cuando pasé de un spinner a SSD (post Gradle), mi velocidad y eficiencia fueron literalmente 2 - 4 veces más rápidas y te prometo que NO estoy exagerando aquí.

Ahora no estoy hablando de tener una máquina con un SSD pequeño y una gran ruleta, estoy hablando de 1 SSD grande. Si ya tiene una máquina con una SSD pequeña y una gran ruleta, puede actualizar la pequeña ruleta para decir una SSD de 500GB y configurar la SSD como su unidad principal del sistema operativo con sus herramientas de desarrollador instaladas.

Entonces, si está trabajando en un entorno de ritmo rápido, muestre esta publicación a su jefe. Un SSD de 1 TB decente te costará alrededor de £ 300 (IVA incluido), o alrededor de £ 160 por un SSD de 500GB. Dependiendo de si usted es un desarrollador de Android junior o senior, la unidad se pagará sola (en gastos salariales) en 1 a 2 semanas hábiles, o alrededor de 2 a 5 días hábiles si invierte en una más pequeña; digamos 500GB SSD.

Muchos desarrolladores pueden argumentar que este no es el caso, pero es el caso de Gradle, ya que el sistema Gradle es muy difícil en el acceso directo al disco. Si trabaja con .NET / C # / VB Net u otras herramientas de desarrollo, no notará mucha diferencia, pero la diferencia en Gradle es ENORME. Si actúas en esta publicación, te lo prometo, no te decepcionará. Personalmente, estoy usando el i7 de quinta generación con 8 GB de RAM, que originalmente venía con un Spinner de 1 TB y lo actualicé a un Samsung SSD 840 EVO de 1 TB y nunca he vuelto a mirar atrás. Compré el mío en: https://www.aria.co.uk .

Espero que esto ayude. También debo decir que esta NO es una publicación comercialmente motivada, solo estoy recomendando a Aria ya que las he usado muchas veces antes y siempre han sido confiables.

Algunos comandos que podemos agregar al archivo gradle.properties:

org.gradle.configureondemand = true: este comando le indicará a gradle que solo cree los proyectos que realmente necesita construir. Utilice Daemon - org.gradle.daemon = true - Daemon mantiene la instancia del gradle en funcionamiento en segundo plano incluso después de que finalice su compilación. Esto eliminará el tiempo requerido para inicializar el gradle y disminuirá significativamente el tiempo de construcción.

org.gradle.parallel = true - Permitir que Gradle construya su proyecto en paralelo. Si tiene varios módulos en su proyecto, al habilitar esto, Gradle puede ejecutar operaciones de compilación para módulos independientes en paralelo.

Aumente el tamaño de almacenamiento dinámico: org.gradle.jvmargs = -Xmx3072m -XX: MaxPermSize = 512m -XX: + HeapDumpOnOutOfMemoryError -Dfile.encoding = UTF-8 - Desde android studio 2.0, gradle utiliza dex en el proceso para disminuir los tiempos de construcción para el proyecto. En general, al compilar las aplicaciones, se ejecutan múltiples procesos dx en diferentes instancias de VM. Pero a partir del Android Studio 2.0, todos estos procesos dx se ejecutan en la única VM y esa VM también se comparte con el gradle. Esto disminuye significativamente el tiempo de compilación ya que todo el proceso dex se ejecuta en las mismas instancias de VM. Pero esto requiere mayor memoria para acomodar todos los procesos dex y gradle. Eso significa que debe aumentar el tamaño de almacenamiento dinámico requerido por el demonio gradle. Por defecto, el tamaño del montón para el demonio es de aproximadamente 1 GB.

Asegúrese de que no se use la dependencia dinámica. es decir, no use la implementación 'com.android.support:appcompat-v7:27.0.+'. Este comando significa que gradle se conectará en línea y buscará la última versión cada vez que compile la aplicación. En su lugar, use versiones fijas, es decir, 'com.android.support:appcompat-v7:27.0.2'

Agregue esto a su gradle.propertiesarchivo

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

Abra gradle.properties desde la carpeta de Android y descomente las líneas resaltadas y proporcione valores de memoria según la configuración de su máquina. Tengo 8 GB de RAM en mi máquina, así que di un máximo de 4096 MB y 1024 MB respectivamente.

# 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

Mi tiempo de construcción se redujo a la mitad después de esto. Edificio feliz !!

A menudo sucede cuando habilitaste multidex en tu proyecto. ¡Esto puede potencialmente retrasar su proceso de desarrollo! Según el documento :

La configuración multidex requiere un tiempo de procesamiento de compilación significativamente mayor porque el sistema de compilación debe tomar decisiones complejas sobre qué clases deben incluirse en el archivo DEX primario y qué clases pueden incluirse en archivos DEX secundarios. Esto significa que las compilaciones incrementales que usan multidex suelen llevar más tiempo y potencialmente pueden ralentizar su proceso de desarrollo.

pero puedes optimizar esto:

Para mitigar tiempos de compilación incrementales más largos, debe usar pre-dexing para reutilizar la salida multidex entre compilaciones.

Si está utilizando Android Studio 2.3 y superior, el IDE usa automáticamente esta característica cuando implementa su aplicación en un dispositivo con Android 5.0 (API nivel 21) o superior.

Por lo tanto, debe establecer minSdkVersion en 21 o superior .

Pero si su versión de producción necesita admitir minSdkVersion inferior a 21, por ejemplo 19

puede usar productFlavors para configurar minSdkVersion 21 para su versión de desarrollo:

    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'
}

Prefiero construir desde la línea de comandos para mejores tiempos de construcción. Si la base de código de su aplicación es grande y tiene varios módulos, puede probar el enfoque AAR local como se describe aquí, le dará un gran impulso en el rendimiento de Android Studio y los tiempos de construcción de Gradle. Es compatible con las construcciones de línea de comando también

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

El proyecto de demostración con instrucciones de integración se puede encontrar aquí: https://github.com/akhgupta/AndroidLocalMavenRepoAARDemo