Eu tenho um multiprojeto (~ 10 módulos) cujo prédio leva cerca de 20 a 30 segundos cada vez. Quando pressiono Executar no Android Studio, tenho que esperar sempre para reconstruir o aplicativo, o que é extremamente lento.

É possível automatizar o processo de construção no Android Studio? Ou você tem algum conselho sobre como tornar esse processo mais rápido?

No Eclipse, graças à criação automática, a execução do mesmo projeto em um emulador leva cerca de 3-5 segundos.

Este é o meu arquivo build.gradle (módulo de aplicativo):

buildscript {
    repositories {
        maven { url 'http://repo1.maven.org/maven2' }
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:0.4'
    }
}
apply plugin: 'android'

dependencies {
    compile fileTree(dir: 'libs', include: '*.jar')
    compile project(':libraries:SharedLibs')
    compile project(':libraries:actionbarsherlock')
    compile project(':libraries:FacebookSDK')
    compile project(':libraries:GooglePlayServices')
    compile project(':libraries:HorizontalGridView')
    compile project(':libraries:ImageViewTouch')
    compile project(':libraries:SlidingMenu')
}

android {
    compileSdkVersion 17
    buildToolsVersion "17.0.0"

    defaultConfig {
        minSdkVersion 8
        targetSdkVersion 16
    }
}

Hardware

Sinto muito, mas atualizar a estação de desenvolvimento para SSD e toneladas de RAM provavelmente tem uma influência maior do que os pontos abaixo combinados.

Versões de ferramentas

Aumentar o desempenho da compilação tem grande prioridade para as equipes de desenvolvimento, portanto, verifique se você está usando os plug-ins Gradle e Android Gradle mais recentes .

Arquivo de configuração

Crie um arquivo nomeado gradle.propertiesem qualquer diretório que se aplique:

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

Acrescentar:

# IDE (e.g. Android Studio) users:
# Settings specified in this file will override any Gradle settings
# configured through the IDE.

# For more details on how to configure your build environment visit
# http://www.gradle.org/docs/current/userguide/build_environment.html

# The Gradle daemon aims to improve the startup and execution time of Gradle.
# When set to true the Gradle daemon is to run the build.
# TODO: disable daemon on CI, since builds should be clean and reliable on servers
org.gradle.daemon=true

# Specifies the JVM arguments used for the daemon process.
# The setting is particularly useful for tweaking memory settings.
# https://medium.com/google-developers/faster-android-studio-builds-with-dex-in-process-5988ed8aa37e#.krd1mm27v
org.gradle.jvmargs=-Xmx5120m -XX:MaxPermSize=512m -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
org.gradle.parallel=true

# Enables new incubating mode that makes Gradle selective when configuring projects. 
# Only relevant projects are configured which results in faster builds for large multi-projects.
# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:configuration_on_demand
org.gradle.configureondemand=true

# Set to true or false to enable or disable the build cache. 
# If this parameter is not set, the build cache is disabled by default.
# http://tools.android.com/tech-docs/build-cache
android.enableBuildCache=true

As propriedades Gradle funcionam localmente se você as colocar projectRoot\gradle.propertiese globalmente se você as colocar em user_home\.gradle\gradle.properties. Propriedades aplicadas se você executar tarefas de classificação no console ou diretamente da ideia:

Configurações IDE

É possível ajustar a integração Gradle-IntelliJ a partir da GUI de configurações do IDE. A ativação do "trabalho offline" (verifique a resposta do yava abaixo) desativará as solicitações reais da rede em todos os "arquivos de sincronização".

Multi-dex nativo

Uma das etapas mais lentas da compilação do apk é converter bytecode em java em um único arquivo dex. A ativação do multidex nativo (minSdk 21 apenas para compilações de depuração) ajudará as ferramentas a reduzir uma quantidade de trabalho (verifique a resposta de Aksel Willgert abaixo).

Dependências

Preferir @aardependências sobre subprojetos de bibliotecas.

Pesquise o pacote aar no mavenCentral , jCenter ou use o jitpack.io para criar qualquer biblioteca do github. Se você não estiver editando fontes da biblioteca de dependências, não deve construí-la sempre com as fontes do projeto.

Antivírus

Considere excluir arquivos de projeto e cache da verificação antivírus. Obviamente, isso é uma troca de segurança (não tente fazer isso em casa!). Mas se você alternar bastante entre as ramificações, o antivírus verificará novamente os arquivos antes de permitir que o processo gradle o use, o que diminui o tempo de criação (em particular o projeto de sincronização do AndroidStudio com arquivos gradle e tarefas de indexação). Avalie o tempo de construção e processe a CPU com e sem o antivírus ativado para verificar se está relacionado.

Criação de perfil de uma construção

Gradle tem suporte embutido para projetos de criação de perfil . Projetos diferentes estão usando uma combinação diferente de plug-ins e scripts personalizados. Usar --profileajudará a encontrar gargalos.

Você pode ignorar as verificações atualizadas da gradle.

Para Windows executando o Android Studio 1.5: Vá para File -> Settings -> Build, Execution, Deployment -> Build tools -> Gradle -> Check Offline work (as shown in image)

de ~ 30 + seg a ~ 3 seg

Pesquisou em todos os lugares por isso e finalmente encontrou uma solução que funciona para nós. Habilitar compilações paralelas (no OSX :) preferences -> compiler -> gradle -> "Compile independent modules in parallel"e habilitar 'criar projeto automaticamente' diminuíram de ~ 1 minuto para ~ 20 segundos. Graças a / u / Covalence.

http://www.reddit.com/r/androiddev/comments/1k3nb3/gradle_and_android_studio_way_slower_to_build/

Recentemente, comprei um novo SSD e fui do Windows para o Linux. Meus tempos de compilação agora são uma ordem de magnitude mais rápida e não são mais irritantes.

Embora não responda diretamente à sua pergunta sobre por que é mais lento que o eclipse, mostra que o processo é delimitado por disco e que a atualização para um SSD pode ser uma solução (um tanto cara). Suponho que haverá pessoas pesquisando a questão e terminando aqui, que poderão apreciar minha experiência.

Acelere a construção do Gradle no Android Studio 3.2.1

Você já sentiu a espera de concluir as compilações no Android Studio por alguns minutos? Eu também. E é muito chato. Felizmente, existem algumas maneiras que você pode usar para melhorar isso. Android usa Gradle para a construção. A versão mais recente é 4.6, com um enorme aumento de desempenho em relação às versões anteriores (consulte as Notas da versão para obter detalhes).

Etapa 1: Atualizar a versão Gradle Uma maneira mais fácil de fazer isso é acessar: Configurações do módulo aberto (seu projeto)> Estrutura do projeto

ATUALIZAR

Altere para a versão Gradle: 4.6 e Altere para a versão do plug-in Android: 3.2.1

Faça o download do Gradle Release distributivo em https://services.gradle.org/distributions/gradle-4.6-all.zip E copie-o para a pasta Gradle:

O último passo é adicionar sua discrição em Configurações> Gradle

Não se esqueça de clicar em Aplicar para salvar as alterações.

Etapa 2: ativar o modo offline, o daemon Gradle e a compilação paralela para o projeto O modo offline instrui o Gradle a ignorar as verificações atualizadas. Gradle solicita dependências sempre e, com essa opção, ela usa apenas o que já está na máquina para dependências. Vá para Gradle no Android studio Setting e clique na caixa de trabalho Off-line.

2. Vá para o Compiler no Android studio Setting e adicione "- offline" na caixa de linha de comando e clique em Compilar módulos independentes em paralelo.

A próxima etapa é ativar o daemon Gradle e a compilação paralela para o seu projeto. Construções paralelas farão com que seus projetos com vários módulos (construções com vários projetos no Gradle) sejam paralelos, o que deve fazer projetos grandes ou modulares serem construídos mais rapidamente.

Essas configurações podem ser ativadas modificando um arquivo chamado gradle.properties no diretório de scripts Gradle (por exemplo, ~ / .gradle / gradle.properties). Algumas dessas opções (por exemplo, módulos Complie em paralelo) estão disponíveis no Android Studio e também são ativadas por o padrão, mas colocá-los no arquivo gradle.properties os habilitará ao criar a partir do terminal e também garantir que seus colegas usem as mesmas configurações. Mas se você estiver trabalhando em equipe, às vezes não poderá cometer essas coisas.

# When configured, Gradle will run in incubating parallel mode.
# This option should only be used with decoupled projects. More details, visit org.gradle.parallel=true
# When set to true the Gradle daemon is used to run the build. For local developer builds this is our favorite property.
# The developer environment is optimized for speed and feedback so we nearly always run Gradle jobs with the daemon.
 org.gradle.daemon=true

O uso do daemon tornará a inicialização de suas compilações mais rápida, pois não será necessário iniciar o aplicativo Gradle inteiro todas as vezes. O Gradle Daemon não está ativado por padrão, mas é recomendável sempre habilitá-lo para as máquinas dos desenvolvedores (mas deixando-o desativado para servidores de integração contínua). As perguntas frequentes sobre este modo podem ser encontradas aqui https://docs.gradle.org/current/userguide/gradle_daemon.html . A configuração de compilações paralelas pode não ser segura para alguns projetos. O requisito é que todos os seus módulos sejam dissociados ou sua compilação possa falhar (consulte http://gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects para obter detalhes).

Etapa 3: ativar as configurações incrementais de dexign e ajustar a memória Você pode acelerar suas construções ativando a dexing incremental. No arquivo de construção do seu módulo:

Adicione esta opção ao seu bloco Android:

dexOptions {
    incremental true
}

Nesse bloco dexOptions, você também pode especificar o tamanho do heap para o processo dex, por exemplo:

dexOptions {
    incremental true
    javaMaxHeapSize "12g"
}

Onde "12g" representa 12 GB de memória. Informações adicionais sobre isso podem ser encontradas aqui google.github.io/android-gradle-dsl/current/ Você também pode configurar os parâmetros Gradle no arquivo de configurações, por exemplo, aumentar o tamanho máximo do heap caso tenha um projeto grande:

# Specifies the JVM arguments used for the daemon process.
# The setting is particularly useful for tweaking memory settings.
# Default value: -Xmx10248m -XX:MaxPermSize=256m
org.gradle.jvmargs=-Xmx2048m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8

Veja toda a lista de parâmetros aqui: https://docs.gradle.org/current/userguide/userguide_single.html#sec:gradle_configuration_properties para obter detalhes.

Passo 4: Desativar antivírus Considere excluir arquivos de projeto e cache da verificação antivírus. Obviamente, isso é uma troca com segurança. Mas se você alternar bastante entre as ramificações, o antivírus verificará novamente os arquivos antes de permitir que o processo gradle o use, o que diminui o tempo de compilação (em particular, o projeto de sincronização do Android Studio com arquivos gradle e tarefas de indexação). Avalie o tempo de construção e processe a CPU com e sem o antivírus ativado para verificar se está relacionado. Eu espero que isso ajude. Deixe um comentário se tiver alguma dúvida ou alguma outra dica para melhorar o desempenho da compilação.

link útil

Se você estiver usando os serviços do Google Play, dependendo apenas das bibliotecas necessárias em vez de todo o blob, as coisas podem ser mais rápidas.

Se sua única necessidade é de mapas, use:

compile 'com.google.android.gms:play-services-maps:6.5.+'

ao invés de:

compile 'com.google.android.gms:play-services:6.5.+'

O último traz métodos de 20k (consulte o blog) no caminho de classe, o que pode reduzir a contagem total de métodos acima de 64k.

Isso forçaria o uso de proguard ou multidex, mesmo para compilações de depuração. Para um dos meus projetos, tive os seguintes tempos de compilação

• compilação multidex (com supportlibrary) ~ 40seg
• construção do programa ~ 20seg
• construir quando o limite do método <64k ~ 5seg

Se estiver desenvolvendo no sdk 21+, seria possível otimizar as compilações multidex, conforme indicado na documentação do Android

android {
    productFlavors {
        // Define separate dev and prod product flavors.
        dev {
            // dev utilizes minSDKVersion = 21 to allow the Android gradle plugin
            // to pre-dex each module and produce an APK that can be tested on
            // Android Lollipop without time consuming dex merging processes.
            minSdkVersion 21
        }
        prod {
            // The actual minSdkVersion for the application.
            minSdkVersion 14
        }
    }
    ...
}

A resposta aceita é para versões mais antigas do android studio e a maioria delas ainda funciona agora. A atualização do android studio tornou um pouco mais rápido. Não se preocupe em especificar o tamanho da pilha, pois ela aumentará automaticamente com o aumento de Xms e Xmx. Aqui estão algumas modificações com as VMoptions

1. Na pasta bin, há um arquivo studio.vmoptions para definir a configuração do ambiente. No meu caso, é studio64.vmoptions Adicione as seguintes linhas, se ainda não tiverem sido adicionadas, e salve o arquivo. No meu caso, tenho 8 GB de RAM.

   -Xms4096m
   -Xmx4096m
   -XX:MaxPermSize=2048m
   -XX:+CMSClassUnloadingEnabled
   -XX:+CMSPermGenSweepingEnabled 
   -XX:+HeapDumpOnOutOfMemoryError
   -Dfile.encoding=utf-8`

2. Inicie o android studio. Vá para Arquivo-> Configurações-> Compilar, Execução, Implantação-> Compilador

   • Verifique compilar módulos independentes em paralelo
   • Nas opções da linha de comando, escreva: --offline
   • Marque Criar projeto automaticamente
   • Verifique a configuração sob demanda

No caso de usar mac, no começo não consegui encontrar as vmoptions. Enfim, aqui está um bom artigo sobre como podemos alterar as vmoptions no MAC OSX . Citando este artigo aqui.

Abra seu terminal e coloque este comando para abrir as vmoptions no MAC OSX:

open -e /Applications/Android\ Studio.app/Contents/bin/studio.vmoptions

Basta criar um arquivo chamado gradle.properties no seguinte diretório:

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

Adicione esta linha ao arquivo:

org.gradle.daemon=true

Para mim, a velocidade agora é igual ao Eclipse.

Fonte: https://www.timroes.de/2013/09/12/speed-up-gradle/

Você pode tornar o processo mais rápido se usar gradle na linha de comando. Há muita otimização para os desenvolvedores de IDE. Mas é apenas uma versão inicial.

Para mais informações, leia esta discussão no g + com alguns dos desenvolvedores.

Se alguém estiver trabalhando em um projeto sincronizado via Subversion e isso ainda estiver acontecendo, acho que isso pode atrasar o processo de fluxo de trabalho no Android Studio. Por exemplo, se funcionar muito lentamente enquanto: rolagem em uma classe, xml etc., enquanto meu aplicativo ainda está sendo executado no meu dispositivo.

• Vá para Controle de versão em Preferências e defina do Subversion para Nenhum.

Atualizar após o Android Studio 2.3

Todas as respostas são ótimas, e eu incentivo a usar esses métodos com este para melhorar a velocidade de construção.

Após o lançamento do Android 2.2 em setembro de 2016, o Android lançou o recurso experimental de cache de compilação para acelerar o gradledesempenho da compilação, que agora é oficial do Android Studio 2.3 Canary. (Nota oficial de lançamento)

Ele introduz um novo recurso de cache de compilação, que é ativado por padrão, pode acelerar os tempos de compilação (incluindo compilações completas, compilações incrementais e execução instantânea) armazenando e reutilizando arquivos / diretórios criados em compilações anteriores do mesmo ou de outro Android projeto.

Como usar:

Adicione a seguinte linha no seu gradle.propertiesarquivo

android.enableBuildCache = true
# Set to true or false to enable or disable the build cache. If this parameter is not set, the build cache is enable by default.

Limpe o cache:

• Há uma nova tarefa Gradle solicitada cleanBuildCachepara que você limpe mais facilmente o cache de compilação. Você pode usá-lo digitando o seguinte em seu terminal:

  ./gradlew cleanBuildCache

• OU Você pode limpar o cache do Android studio 2.2 excluindo todos os arquivos armazenados no local

  C:\Users\<username>\.android\build-cache

Depois de alterar essas configurações, minha duração de compilação 10 minutos mudou para ~ 10 segundos.

Passo 1:

Configurações (ctrl + Alt + S) ->

Compilação, Execução, Implantação ->

Compilador ->

digite " --offline" na caixa Opções da linha de comando.

Passo 2:

marque a caixa de seleção "Compilar módulos independentes em paralelo".

e clique em Aplicar -> OK

Referência - https://www.sundoginteractive.com/blog/speed-up-gradle-in-android-studio

Desvantagem:

Você não poderá baixar as versões mais recentes das dependências identificadas no seu arquivo build.gradle. Ele roda mais rápido porque usa um instantâneo em cache dessas bibliotecas importadas.

Nota importante : Ao implantar o aplicativo, remova essas configurações e construa com as versões mais recentes das dependências.

Mina resolvida com

File -> Settings -> Build, Execution, Deployment -> Build Tools -> Gradle -> Offline work

As versões do Gradle passaram de 8 minutos para 3 segundos.

Aqui está o que ajudou esse programador iniciante do Android (ex-programador profissional, anos atrás) a acelerar o Android Studio 2.2. Eu sei que isso é uma reformulação, mas, apenas resumindo em um só lugar.

As versões iniciais ainda podem ser brutalmente lentas, mas as reinicializações de aplicativos em execução agora são geralmente muito toleráveis. Estou usando um PC subótimo: CPU AMD Quad-Core A8-7410, 8 MB de RAM, HD sem SSD, Win 10. (E, esta é minha primeira postagem no Stack Overflow ....;)

EM CONFIGURAÇÕES -> GRADLE:

sim para "Trabalho off-line" (talvez essa seja a configuração mais importante).

EM CONFIGURAÇÕES -> COMPILADOR:

yes para "Compile módulos independentes em paralelo" (não tenho certeza se isso de fato ajuda a utilizar CPUs multicore).

EM GRADLE SCRIPTS , "build.gradle (Módulo: app)":

defaultConfig {
    ...
   // keep min high so that restarted apps can be hotswapped...obviously, this is hugely faster.
   minSdkVersion 14
   ...
    // enabling multidex support...does make big difference for me.
    multiDexEnabled true

TAMBÉM EM SCRIPTS GRADLE , "gradle.properties (Propriedades do Projeto)":

org.gradle.jvmargs = -Xmx3048m -XX: MaxPermSize = 512m -XX: + HeapDumpOnOutOfMemoryError -Dfile.encoding = UTF-8

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

Além disso , o teste em um dispositivo físico em vez do emulador está funcionando bem para mim; um pequeno tablet que se levanta é conveniente.

Apenas mais uma dica de melhoria de desempenho:

O Android Studio 3.0 inclui o novo compilador DEX chamado D8.

"O compilador dex funciona principalmente sob o capô no desenvolvimento diário do seu aplicativo, mas afeta diretamente o tempo de criação do aplicativo, o tamanho do arquivo .dex e o desempenho do tempo de execução."

"E ao comparar o novo compilador D8 com o atual compilador DX, o D8 compila mais rapidamente e gera arquivos .dex menores, mantendo o mesmo ou melhor desempenho em tempo de execução do aplicativo".

D8 é opcional - use-o para colocar no gradle.properties do projeto

android.enableD8=true

Mais informações: https://android-developers.googleblog.com/2017/08/next-generation-dex-compiler-now-in.html

PS. Impulsionou meu tempo de construção em cerca de 30%.

Essa configuração é muito rápida para mim (cerca de 2 segundos após a compilação)

build.gradle

android {

    dexOptions {
        incremental true
        preDexLibraries = false
        jumboMode = false
        maxProcessCount 4
        javaMaxHeapSize "6g"
    }
}

gradle.properties

org.gradle.daemon=true
org.gradle.parallel=true
org.gradle.jvmargs=-Xmx8192M

meu PC:

• CPU Processador Intel® Pentium® G2030 @ 3.00GHz, 3000 Mhz, 2 processadores principais, 2 processos lógicos
• x64
• Microsoft Windows 7 Professional
• (RAM) 16,0 GB

arquivos de projeto
- todos localizados em HD local

Por favor, siga os seguintes passos.

1. Ativar modo offline: Verifique abaixo a tela de impressão.

   https://i.stack.imgur.com/RF9uG.png

2. Ativar execução instantânea: verifique abaixo a tela de impressão.

   https://i.stack.imgur.com/mvHKJ.png

   Se você quiser saber mais sobre a execução instantânea, visite o site do desenvolvedor do Android.

Você pode tentar abrir o menu gradle no lado direito do estúdio, montar apenas os módulos alterados e executar o comando install. Quando você pressiona executar, ele monta tudo, independentemente de quaisquer alterações que você possa ter feito no código que está montando

Estou longe de ser um especialista em Gradle, mas meu ambiente tinha a seguinte linha em .gradle / init.gradle

gradle.projectsLoaded {
    rootProject.allprojects {
        repositories {
            mavenRepo name: 'libs-repo', url: 'http://guest-vm/artifactory/repo'
        }
    }
}

No entanto, não tenho idéia do porquê dessa linha, mas tento mudar para

gradle.projectsLoaded {
    rootProject.allprojects {
        repositories {
            mavenCentral()
        }
    }
} 

e agora finalmente posso trabalhar sem jurar pelo esquema de construção do Android Studio e Gradle.

No nosso caso específico, o problema ocorreu devido à retrolambda in , que forçou todos os projetos e subprojetos a se recompilarem sempre que tentamos iniciar nosso aplicativo, mesmo que nenhum código tenha sido alterado em nossos módulos principais.

A remoção do retrolamba o corrigiu para nós. Espero que ajude alguém.

Apenas tente isso primeiro. É a minha experiência pessoal.

Eu tive o mesmo problema. O que eu fiz foi desativar permanentemente o antivírus (o Mine era o Avast Security 2015). Logo após desativar o antivírus, tudo correu bem. o gradle terminou com sucesso. A partir de segundos, o gradle está terminando (levando apenas 5 a 10 segundos).

Oi, eu sei que esta é uma resposta muito, muito tarde, mas talvez ajude alguém
no meu caso, eu estava usando

compile 'com.android.support:support-v4:23.1.1'

no meu aplicativo dependência Gradle,
mas em uma das minhas bibliotecas era

 compile 'com.android.support:support-v4:23.0.1'

depois de mudar tudo para a versão mais recente, meu problema foi resolvido.

Seguir as etapas o tornará 10 vezes mais rápido e reduzirá o tempo de construção em 90%

Primeiro, crie um arquivo chamado gradle.properties no seguinte diretório:

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

Adicione esta linha ao arquivo:

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

E marque estas opções no Android Studio

Use este sudo dpkg --add-architecture i386 sudo apt-get update sudo apt-get install libncurses5: i386 libstdc ++ 6: i386 zlib1g: i386

O Android Studio falha ao criar um novo projeto, o tempo limite excedeu o tempo limite durante o processo de aapt slave

Uma alteração trivial (para um xml de reabsorção) ainda levou 10 minutos . Como o @rivare diz em sua resposta, a criação de uma linha de comando é mais rápida (levou isso para 15 segundos ).
Aqui estão algumas etapas para, pelo menos, tornar uma construção trivial rápida a partir da linha de comando do Windows.

1. Vá para a raiz do seu projeto (onde está o gradlew.bat):

   cd c: \ android \ MaskActivity

2. execute a compilação :

   gradlew assembleDebug

3. desinstale o apk diretamente do telefone (arraste-o para desinstalar).

4. Quando a compilação estiver concluída, mate o processo java BIG usando o Gerenciador de Tarefas do Windows.

OU se você possui ferramentas unix em sua máquina Windows:

ps

Os "pid" são mostrados:

kill -9 <pid>

5. Agora instale seu apk:

   adb -d instala C: \ Android \ MaskActivity \ app \ build \ outputs \ apk \ app-debug.apk

De acordo com a documentação do Android , adicione isso no arquivo gradle do módulo de aplicativo.

android {
    ...
    dexOptions {
    preDexLibraries true
    maxProcessCount 8
    }
}

Para executar o ambiente Android na máquina de baixa configuração.

1. Feche as guias da web desnecessárias no navegador
2. Para usuários de antivírus, exclua a pasta de compilação gerada automaticamente

3. O estúdio Android tem um heap padrão de 1,2 Gb que pode diminuir para 512 MB Ajuda> Editar opções personalizadas da VM studio.vmoptions -Xmx512m O desempenho dos layouts será acelerado

4. Para Gradle, um dos componentes principais do estúdio Android Mkae, com certeza, como agora, 3.0beta é o mais recente

As dicas abaixo podem afetar a qualidade do código; portanto, use com cuidado:

1. O Studio contém o Modo de economia de energia, quando ativado, fecha as operações em segundo plano que fiam, complementam o código e assim por diante.

2. Você pode executar a verificação manual do lint quando necessário ./gradlew lint

3. A maioria deles usa emuladores Android, em média, consome 2 GB de RAM; portanto, se possível, use o dispositivo Android real, pois isso reduzirá a carga de recursos no seu computador. Como alternativa, você pode reduzir a RAM do emulador e isso reduzirá automaticamente o consumo de memória virtual no seu computador. você pode encontrar isso na configuração do dispositivo virtual e na configuração avançada.

4. O modo offline Gradle é um recurso para usuários com largura de banda limitada para desativar o download de dependências de compilação. Reduzirá a operação em segundo plano que ajudará a aumentar o desempenho do Android studio.

5. O Android studio oferece uma otimização para compilar vários módulos em paralelo. Em máquinas com pouca RAM, esse recurso provavelmente terá um impacto negativo no desempenho. Você pode desativá-lo na caixa de diálogo de configurações do compilador.