Mam wiele projektów (~ 10 modułów), których budowanie za każdym razem zajmuje około 20-30 sekund. Po naciśnięciu przycisku Uruchom w Android Studio muszę za każdym razem czekać na przebudowanie aplikacji, co jest bardzo wolne.

Czy można zautomatyzować proces budowania w Android Studio? Czy masz jakieś porady, jak przyspieszyć ten proces?

W Eclipse, dzięki automatycznemu budowaniu, uruchomienie tego samego projektu na emulatorze zajmuje około 3-5 sekund.

To jest mój plik build.gradle (moduł aplikacji):

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

Sprzęt komputerowy

Przykro mi, ale uaktualnienie stacji rozwojowej do SSD i ton pamięci RAM ma prawdopodobnie większy wpływ niż łącznie poniższe punkty.

Wersje narzędzi

Zwiększenie wydajności kompilacji ma główny priorytet dla zespołów programistycznych, więc upewnij się, że korzystasz z najnowszej wtyczki Gradle i Android Gradle .

Plik konfiguracyjny

Utwórz plik o nazwie gradle.propertiesw dowolnym katalogu:

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

Dodać:

# 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

Właściwości Gradle działają lokalnie, jeśli je projectRoot\gradle.propertiesumieścisz, a globalnie, jeśli je umieścisz user_home\.gradle\gradle.properties. Właściwości stosowane, jeśli uruchamiasz zadania stopniowe z konsoli lub bezpośrednio z pomysłu:

Ustawienia IDE

Możliwe jest dostosowanie integracji Gradle-IntelliJ z GUI ustawień IDE. Włączenie „pracy offline” (sprawdź odpowiedź z yava poniżej) spowoduje wyłączenie rzeczywistych żądań sieciowych na każdym „pliku stopni synchronizacji”.

Natywny multi-dex

Jednym z najwolniejszych kroków kompilacji apk jest konwersja kodu bajtowego java na pojedynczy plik dex. Włączenie natywnego multidexu (minSdk 21 tylko dla kompilacji debugowania) pomoże oprzyrządowaniu zmniejszyć ilość pracy (sprawdź odpowiedź Aksel Willgert poniżej).

Zależności

Preferuj @aarzależności od podprojektów bibliotecznych.

Wyszukaj pakiet aar na mavenCentral , jCenter lub użyj jitpack.io, aby zbudować dowolną bibliotekę z github. Jeśli nie edytujesz źródeł biblioteki zależności, nie powinieneś budować jej za każdym razem ze źródłami projektu.

Antywirusowe

Rozważ wykluczenie plików projektu i pamięci podręcznej ze skanowania antywirusowego. Jest to oczywiście kompromis z bezpieczeństwem (nie próbuj tego w domu!). Ale jeśli często przełączasz się między gałęziami, program antywirusowy ponownie przeskanuje pliki przed zezwoleniem procesowi gradacji na użycie, co spowalnia czas kompilacji (w szczególności projekt synchronizacji AndroidStudio z plikami stopni i zadaniami indeksowania). Zmierz czas kompilacji i przetwarzaj procesor z włączonym programem antywirusowym i bez niego, aby sprawdzić, czy jest on powiązany.

Profilowanie kompilacji

Gradle ma wbudowaną obsługę projektów profilowania . Różne projekty używają innej kombinacji wtyczek i niestandardowych skryptów. Używanie --profilepomoże znaleźć wąskie gardła.

Możesz zignorować sprawdzanie bieżącej aktualizacji stopni.

W systemie Windows z Android Studio 1.5: Idź do File -> Settings -> Build, Execution, Deployment -> Build tools -> Gradle -> Check Offline work (as shown in image)

w dół z ~ 30 + sekund do ~ 3 sekund

Szukałem tego wszędzie i wreszcie znalazłem rozwiązanie, które nam odpowiada. Włączenie kompilacji równoległych (w OSX:) preferences -> compiler -> gradle -> "Compile independent modules in parallel"i włączenie opcji „twórz projekt automatycznie” obniżyło go z ~ 1 minuty do ~ 20 sekund. Dzięki / u / Covalence.

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

Niedawno kupiłem nowy dysk SSD i przeszedłem z systemu Windows na Linux. Moje czasy kompilacji są teraz o rząd wielkości szybsze i nie są już denerwujące.

Chociaż nie odpowiada bezpośrednio na twoje pytanie, dlaczego jest wolniejszy niż zaćmienie, pokazuje, że proces jest ograniczony dyskiem, a aktualizacja dysku SSD może być (nieco kosztownym) rozwiązaniem. Zgaduję, że znajdą się ludzie, którzy wyszukają problem i znajdą się tutaj, którzy mogą docenić moje doświadczenie.

Przyspieszenie gradla wbudowane w Android Studio 3.2.1

Czy kiedykolwiek czułeś się, jakbyś czekał na ukończenie kompilacji w Android Studio przez kilka minut? Ja też. I to jest dość denerwujące. Na szczęście istnieje kilka sposobów, aby to poprawić. Android używa Gradle do budowania. Najnowsza wersja 4.6 ma ogromny wzrost wydajności w porównaniu do poprzednich wersji (szczegółowe informacje znajdują się w Uwagach do wydania).

Krok 1: Zaktualizuj wersję stopniową Łatwiejszym sposobem na osiągnięcie tego jest przejście do: Otwórz Ustawienia modułu (twój projekt)> Struktura projektu

AKTUALIZACJA

Zmień na wersję Gradle: 4.6 i Zmień na wersję wtyczki Android: 3.2.1

Pobierz wersję dystrybucyjną Gradle Release ze strony https://services.gradle.org/distribution/gradle-4.6-all.zip I skopiuj ją do folderu Gradle:

Ostatnim krokiem jest dodanie opisu w Ustawieniach> Stopień

Nie zapomnij kliknąć Zastosuj, aby zapisać zmiany.

Krok 2: Włącz tryb offline, demona Gradle i kompilację równoległą dla projektu Tryb offline informuje Gradle, aby zignorował sprawdzanie aktualizacji na bieżąco. Gradle prosi o zależności za każdym razem, a ta opcja sprawia, że ​​używa tylko zależności, które są już na komputerze. Idź do Gradle z Android Studio Setting i kliknij w polu Praca offline.

2. Przejdź do kompilatora z Android Studio Setting i dodaj „- offline” w polu wiersza poleceń i kliknij Kompiluj niezależne moduły równolegle.

Następnym krokiem jest włączenie demona Gradle i kompilacji równoległej dla twojego projektu. Równoległe kompilacje spowodują, że twoje projekty z wieloma modułami (kompilacje wielu projektów w Gradle) będą budowane równolegle, co powinno przyspieszyć budowę dużych lub modułowych projektów.

Te ustawienia można włączyć, modyfikując plik o nazwie gradle.properties w katalogu skryptów Gradle (tj. ~ / .Gradle / gradle.properties). Niektóre z tych opcji (np. Równoległe moduły Complie) są dostępne w Android Studio, a także dostępne tam przez domyślnie, ale umieszczenie ich w pliku gradle.properties pozwoli im na budowanie z terminala, a także upewni się, że twoi koledzy będą używać tych samych ustawień. Ale jeśli pracujesz w zespole, czasem nie możesz tego zrobić.

# 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

Użycie demona przyspieszy uruchamianie kompilacji, ponieważ nie będzie musiał za każdym razem uruchamiać całej aplikacji Gradle. Demon Gradle nie jest domyślnie włączony, ale zaleca się, aby zawsze włączać go na komputerach programistów (ale pozostawiając wyłączony dla serwerów ciągłej integracji). Często zadawane pytania dotyczące tego trybu można znaleźć tutaj https://docs.gradle.org/current/userguide/gradle_daemon.html . Ustawienie kompilacji równoległych może być niebezpieczne dla niektórych projektów. Wymagane jest, aby wszystkie moduły musiały być oddzielone od siebie, aby kompilacja nie powiodła się (zobacz http://gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects ).

Krok 3: Włącz ustawienia przyrostowego rysowania i poprawiania pamięci Możesz przyspieszyć swoje kompilacje, włączając przyrostowe rysowanie. W pliku kompilacji modułu:

Dodaj tę opcję do bloku Androida:

dexOptions {
    incremental true
}

W tym bloku dexOptions można również określić rozmiar sterty dla procesu dex, na przykład:

dexOptions {
    incremental true
    javaMaxHeapSize "12g"
}

Gdzie „12g” to 12 GB pamięci. Dodatkowe informacje na ten temat można znaleźć tutaj google.github.io/android-gradle-dsl/current/ Możesz również skonfigurować parametry Gradle w pliku ustawień, np. Zwiększyć maksymalny rozmiar sterty w przypadku dużego projektu:

# 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

Zobacz całą listę parametrów tutaj: https://docs.gradle.org/current/userguide/userguide_single.html#sec:gradle_configuration_properties, aby uzyskać szczegółowe informacje.

Krok 4: Wyłącz program antywirusowy Rozważ wykluczenie plików projektu i pamięci podręcznej ze skanowania antywirusowego. Jest to oczywiście kompromis z bezpieczeństwem. Ale jeśli często przełączasz się między gałęziami, program antywirusowy ponownie przeskanuje pliki przed zezwoleniem procesowi gradacji na użycie, co spowalnia czas kompilacji (w szczególności projekt synchronizacji Android Studio z plikami stopni i zadaniami indeksowania). Zmierz czas kompilacji i przetwarzaj procesor z włączonym programem antywirusowym i bez niego, aby sprawdzić, czy jest on powiązany. Mam nadzieję, że to pomoże. Zostaw komentarz, jeśli masz jakieś pytania lub inne wskazówki dotyczące poprawy wydajności kompilacji.

pomocny link

Jeśli korzystasz z usług Google Play, w zależności od potrzebnych bibliotek zamiast całego obiektu blob może to przyspieszyć.

Jeśli potrzebujesz tylko map, użyj:

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

zamiast:

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

Ten ostatni przynosi 20k metod (patrz blog) do ścieżki klasy , co może przewrócić całkowitą liczbę metod ponad 64 tys.

Zmusiłoby to użycie proguard lub multidex nawet do kompilacji debugowania. W przypadku jednego z moich projektów miałem następujące czasy kompilacji

• kompilacja multidex (z biblioteką pomocniczą) ~ 40sec
• kompilacja proguarda ~ 20 sekund
• buduj, gdy limit metody <64k ~ 5sec

Jeśli programujesz na sdk 21+, można zoptymalizować kompilacje multidex, zgodnie z dokumentacją Androida

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

Akceptowana odpowiedź dotyczy starszych wersji Androida Studio i większość z nich działa nadal. Aktualizacja Androida Studio trochę przyspieszyła. Nie zawracaj sobie głowy określaniem wielkości sterty, ponieważ wzrośnie ona automatycznie wraz ze wzrostem Xms i Xmx. Oto niektóre modyfikacje z VMoptions

1. W folderze bin znajduje się plik studio.vmoptions do ustawienia konfiguracji środowiska. W moim przypadku jest to studio64.vmoptions Dodaj następujące wiersze, jeśli jeszcze nie zostały dodane, i zapisz plik. W moim przypadku mam 8 GB pamięci RAM.

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

2. Uruchom studio Android. Przejdź do Plik-> Ustawienia-> Kompilacja, wykonanie, wdrożenie-> Kompilator

   • Sprawdź kompiluj niezależne moduły równolegle
   • W opcjach wiersza polecenia wpisz: --offline
   • Zaznacz opcję Utwórz projekt automatycznie
   • Sprawdź konfigurację na żądanie

W przypadku korzystania z Maca, na początku nie mogłem znaleźć opcji vm. Tak czy inaczej , oto fajny artykuł o tym, jak możemy zmienić opcje vm w MAC OSX . Cytując z tego artykułu tutaj.

Otwórz terminal i wprowadź to polecenie, aby otworzyć opcje vm w systemie MAC OSX:

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

Wystarczy utworzyć plik o nazwie gradle.properties w następującym katalogu:

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

Dodaj ten wiersz do pliku:

org.gradle.daemon=true

Dla mnie prędkość jest teraz równa Eclipse.

Źródło: https://www.timroes.de/2013/09/12/speed-up-gradle/

Możesz przyspieszyć proces, jeśli użyjesz stopniowania z linii poleceń. Jest wiele optymalizacji dla programistów IDE. Ale to tylko wczesna wersja.

Aby uzyskać więcej informacji, przeczytaj tę dyskusję na temat g + z niektórymi twórcami.

Jeśli ktoś pracuje nad projektem, który jest zsynchronizowany przez Subversion i nadal tak się dzieje, myślę, że może to spowolnić proces przepływu pracy w Android Studio. Na przykład, jeśli działa bardzo wolno podczas: przewijania w klasie, xml itp., Gdy moja aplikacja nadal działa na moim urządzeniu.

• Przejdź do Kontrola wersji w Preferencjach i ustaw z Subversion na Brak.

Aktualizacja po Android Studio 2.3

Wszystkie odpowiedzi są świetne i zachęcam do korzystania z tych metod w celu poprawy szybkości kompilacji.

Po wydaniu Androida 2.2 we wrześniu 2016 r., Android wydał funkcję eksperymentalnej pamięci podręcznej kompilacji, aby przyspieszyć gradlewydajność kompilacji, która jest teraz oficjalna z Android Studio 2.3 Canary. (Oficjalna informacja o wydaniu)

Wprowadza nową funkcję pamięci podręcznej kompilacji, która jest domyślnie włączona, może przyspieszyć czasy kompilacji (w tym kompilacje pełne, kompilacje przyrostowe i natychmiastowe uruchamianie) poprzez przechowywanie i ponowne wykorzystywanie plików / katalogów utworzonych w poprzednich kompilacjach tego samego lub innego Androida projekt.

Jak używać:

Dodaj następujący wiersz w swoim gradle.propertiespliku

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.

Wyczyść pamięć podręczną:

• Nowe zadanie Gradle wzywa cleanBuildCachedo łatwiejszego czyszczenia pamięci podręcznej kompilacji. Możesz z niego skorzystać, wpisując w swoim terminalu:

  ./gradlew cleanBuildCache

• LUB Możesz wyczyścić pamięć podręczną dla Androida studio 2.2, usuwając wszystkie pliki z plikami w lokalizacji

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

Po zmianie tych ustawień mój czas kompilacji 10 minut zmieniono na ~ 10 sekund.

Krok 1:

Ustawienia (ctrl + Alt + S) ->

Kompilacja, wykonanie, wdrożenie ->

Kompilator ->

wpisz „ --offline” w polu Opcje wiersza polecenia.

Krok 2:

zaznacz pole „Kompiluj niezależne moduły równolegle”.

i kliknij Zastosuj -> OK

Odniesienie - https://www.sundoginteractive.com/blog/speed-up-gradle-in-android-studio

Niekorzyść:

Nie będzie można pobrać najnowszych wersji zależności określonych w pliku build.gradle. Działa szybciej, ponieważ wykorzystuje buforowaną migawkę tych importowanych bibliotek.

Ważna uwaga : po wdrożeniu aplikacji usuń to ustawienie i skompiluj z najnowszymi wersjami zależności.

Rozwiązałem mój z

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

Wersje Gradle wzrosły z 8 minut do 3 sekund.

Oto, co pomogło temu początkującemu programistowi Androida (dawnemu profesjonalnemu programistowi, lata temu) przyspieszyć Android Studio 2.2. Wiem, że to powtórka, ale podsumowując w jednym miejscu.

Początkowe kompilacje mogą być brutalnie powolne, ale ponowne uruchomienie uruchomionych aplikacji jest obecnie zwykle bardzo tolerowane. Używam nieoptymalnego komputera: czterordzeniowy procesor AMD A8-7410, 8 MB pamięci RAM, dysk SSD bez HDD, Win 10. (I to mój pierwszy komunikat o przepełnieniu stosu ....;)

W USTAWIENIACH -> GRADLE:

tak dla „Praca offline” (jest to chyba najbardziej importowane ustawienie).

W USTAWIENIACH -> KOMPILER:

tak dla „Kompiluj niezależne moduły równolegle” (nie jestem pewien, czy to faktycznie pomaga w wykorzystaniu procesorów wielordzeniowych).

W PISMACH GRADLE „build.gradle (Module: 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

RÓWNIEŻ W PISANKACH , „gradle.properties (właściwości projektu)”:

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

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

Dodatkowo , testowanie na urządzeniu fizycznym zamiast emulatora działa dla mnie dobrze; mały tablet, który wstaje, jest wygodny.

Kolejna wskazówka dotycząca poprawy wydajności:

Android Studio 3.0 zawiera nowy kompilator DEX o nazwie D8.

„Kompilator dex działa głównie pod maską podczas codziennego tworzenia aplikacji, ale bezpośrednio wpływa na czas kompilacji aplikacji, rozmiar pliku .dex i wydajność środowiska wykonawczego”.

„A porównując nowy kompilator D8 z bieżącym kompilatorem DX, D8 kompiluje się szybciej i wyświetla mniejsze pliki .dex, zachowując tę ​​samą lub lepszą wydajność środowiska uruchomieniowego aplikacji.”

D8 jest opcjonalny - skorzystaj z niego, musimy umieścić w gradle.properties projektu

android.enableD8=true

Więcej informacji: https://android-developers.googleblog.com/2017/08/next-generation-dex-compiler-now-in.html

PS. Poprawia mój czas budowy o około 30%.

Ta konfiguracja przebiega dla mnie bardzo szybko (około 2 sekund kompilacji)

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

mój komputer:

• Procesor Intel (R) Pentium (R) CPU G2030 @ 3.00GHz, 3000 MHz, 2 procesadores principales, 2 procesadores lógicos
• x64
• Microsoft Windows 7 Professional
• (RAM) 16,0 GB

pliki projektów
- wszystkie w lokalnym HD

Wykonaj następujące kroki.

1. Włącz tryb offline: sprawdź poniżej ekranu drukowania.

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

2. Włącz natychmiastowe uruchamianie: sprawdź poniższy ekran drukowania.

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

   Jeśli chcesz dowiedzieć się więcej o natychmiastowym uruchomieniu, odwiedź witrynę programisty Androida.

Możesz spróbować otworzyć menu stopni po prawej stronie studia i złożyć tylko te moduły, które zmieniłeś, a następnie uruchomić polecenie instalacji. Kiedy naciśniesz „uruchom”, wszystko się składa, bez względu na zmiany, które wprowadziłeś w kodzie, który gromadzisz

Daleki jestem od bycia ekspertem w dziedzinie Gradle, ale moje środowisko ma następującą linię w .gradle / init.gradle

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

Jednak nie mam pojęcia, dlaczego ta linia tam była, ale staram się zmienić

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

a teraz w końcu mogę pracować bez przeklinania na schemat kompilacji Android Studio i Gradle.

W naszym konkretnym przypadku problem wynikał z posiadania retrolambdy wtyczką , która zmusiła wszystkie projekty i podprojekty do ponownej kompilacji za każdym razem, gdy próbowaliśmy uruchomić naszą aplikację, nawet jeśli żaden kod nie został zmieniony w naszych podstawowych modułach.

Usunięcie retrolamby naprawiło to dla nas. Mam nadzieję, że to komuś pomoże.

Spróbuj tego najpierw. To moje osobiste doświadczenie.

Miałem ten sam problem. To, co zrobiłem, to po prostu trwałe wyłączenie programu antywirusowego (moim był Avast Security 2015). Zaraz po wyłączeniu antywirusa wszystko poszło dobrze. stopień zakończył się powodzeniem. Od teraz w ciągu kilku sekund grad się kończy (zajmuje tylko 5-10 sekund).

Cześć, wiem, że to bardzo późna odpowiedź, ale może pomóc komuś
w moim przypadku, którego używałem

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

w mojej aplikacji zależność Gradle,
ale w jednej z moich bibliotek tak było

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

po zmianie wszystkich na najnowszą wersję mój problem został rozwiązany.

Wykonanie tych kroków sprawi, że będzie to 10 razy szybsze i skróci czas budowy o 90%

Najpierw utwórz plik o nazwie gradle.properties w następującym katalogu:

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

Dodaj ten wiersz do pliku:

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

I sprawdź te opcje w Android Studio

UŻYJ tego sudo dpkg --add-architecture i386 sudo apt-get update sudo apt-get install libncurses5: i386 libstdc ++ 6: i386 zlib1g: i386

Android Studio nie buduje nowego projektu, upłynął limit czasu podczas oczekiwania na proces aapt slave

Trywialna zmiana (na xml resoruce) nadal trwało 10 minut . Jak mówi @rivare w swojej odpowiedzi, kompilacja wiersza poleceń jest szybsza (zmniejszono to do 15 sekund ).
Oto kilka kroków, które pozwolą przynajmniej szybko zbudować trywialną wersję z wiersza poleceń systemu Windows.

1. Przejdź do katalogu głównego projektów (gdzie znajduje się gradlew.bat):

   cd c: \ android \ MaskActivity

2. wykonaj kompilację :

   gradlew asembleDebug

3. odinstaluj apk bezpośrednio z telefonu (przeciągnij go, aby odinstalować).

4. Po zakończeniu kompilacji zabij proces BIG Javy za pomocą Menedżera zadań Windows.

LUB jeśli masz narzędzia uniksowe na komputerze z systemem Windows:

ps

Wyświetlane są „pid”:

kill -9 <pid>

5. Teraz zainstaluj apk:

   adb -d zainstaluj C: \ Android \ MaskActivity \ app \ build \ Output \ apk \ app-debug.apk

Zgodnie z dokumentacją Androida , dodaj to do pliku stopni modułu aplikacji.

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

Aby uruchomić środowisko Android na maszynie o niskiej konfiguracji.

1. Zamknij niepotrzebne karty internetowe w przeglądarce
2. W przypadku użytkowników antywirusowych wyklucz folder kompilacji, który jest generowany automatycznie

3. Android studio ma domyślną stertę 1,2 Gb, może zmniejszyć się do 512 MB Pomoc> Edytuj niestandardowe studio opcji maszyn wirtualnych. Vmoptions -Xmx512m Wydajność układów zostanie przyspieszona

4. Dla Gradle jeden z podstawowych składników studia Android Mkae na pewno teraz 3.0beta jest najnowsza

Poniższe wskazówki mogą wpłynąć na jakość kodu, dlatego należy zachować ostrożność:

1. Program Studio zawiera tryb oszczędzania energii, gdy jest włączony, zamyka operacje w tle, które nie zostawiają włókien, uzupełniają kod i tak dalej.

2. W razie potrzeby możesz uruchomić ręcznie lintcheck ./gradlew lint

3. Większość korzysta z emulatorów Androida, zużywa średnio 2 GB pamięci RAM, więc jeśli to możliwe, użyj rzeczywistego urządzenia z Androidem, co zmniejszy obciążenie twojego komputera. Alternatywnie możesz zmniejszyć ilość pamięci RAM emulatora, a to automatycznie zmniejszy zużycie pamięci wirtualnej na twoim komputerze. można to znaleźć w konfiguracji urządzenia wirtualnego i ustawieniach zaawansowanych.

4. Tryb stopniowy offline to funkcja dla użytkowników o ograniczonej przepustowości, która wyłącza pobieranie zależności kompilacji. Zmniejszy to działanie w tle, co pomoże zwiększyć wydajność studia Android.

5. Android studio oferuje optymalizację do kompilacji wielu modułów równolegle. Na komputerach o niskiej pamięci RAM ta funkcja prawdopodobnie będzie miała negatywny wpływ na wydajność. Możesz go wyłączyć w oknie dialogowym ustawień kompilatora.