Develop Reference

Android Studio freezes on open Big Sur

So I've been using Android Studio 4.2 on my mac with no issue for quite some time, however today while in the middle of working on an app it froze for about 20 minutes until eventually I force quit it. Everytime i try reopening it it is immediatley frozen and shows this error:
My activity monitor also reports that it is using 950% of my CPU (I only have 6 cores). I have tried increasing the memory of Xmx like it says quite high, my system has 32gb of DDR4 so it should be fine but no change i make seems to actually do anything and the application just remains frozen.
Anyone have a similar issue or ideas of how to fix it?

Introduction:
This is the documentation that contains more specific details.
In your case use WAY1 of 2 ways to get to the configuration file.
WAY 1 - Reaching file through Directory + Documentation:
macOS
Syntax: ~/Library/Application Support/Google/<product><version>
Example: ~/Library/Application Support/Google/AndroidStudio4.1
Windows
Syntax: %APPDATA%\Google\<product><version>
Example: C:\Users\YourUserName\AppData\Roaming\Google\AndroidStudio4.1
Linux
Syntax: ~/.config/Google/<product><version>
Example: ~/.config/Google/AndroidStudio4.1
For Android Studio versions 4.0 and lower, configuration files are located in the following locations:
Windows: %USERPROFILE%\.CONFIGURATION_FOLDER
macOS: ~/Library/Preferences/CONFIGURATION_FOLDER
Linux: ~/.CONFIGURATION_FOLDER
There should be a studio64.exe.vmoptions file, you also can reach through the steps below.
WAY 2 - Reaching file in Android Studio:
You can create/edit this file by accessing "Edit Custom VM Options" from the "Help" menu at the top section.
General Settings for memory:
For quick access to increase your "Maximum heap size" I write this steps for better overview:
Click File > Settings from the menu bar (or Android Studio > Preferences on macOS).
Click Appearance & Behavior > System Settings > Memory Settings.
Adjust the heap sizes to match your desired amounts.
Click Apply.
Note: If you changed the heap size for the IDE, you must restart Android Studio before the new memory settings are applied.
After you reached the file studio64.exe.vmoptions:
Edit it in Android Studio (1. Headline) or right click it and "Edit" with Notepad or Textdocument. Now the studio64.exe.vmoptions should contain following line of codes:
-Xms128m
-Xmx4096m
-XX:MaxPermSize=1024m
-XX:ReservedCodeCacheSize=200m
-XX:+UseCompressedOops
Xmx specifies the maximum memory allocation pool for a Java Virtual Machine (JVM), while Xms specifies the initial memory allocation pool. Your JVM will be started with Xms amount of memory and will be able to use a maximum of Xmx amount of memory.
Save the studio64.exe.vmoptions file and restart Android Studio.
Restart IDE and clear your Cache:
Since Android Studio is based on IntelliJ, the option should be in the same place. It's a feature you would seldom use unless your file caches went ballistic (and that can happen every now and then).
Under File > Invalidate Caches/Restart, you'll find an option that lets you either invalidate the caches (and you'll have to rebuild indexes again), or just restart the IDE.
What in this specific case helped:
#Quinn did a reinstallation because he had no access inside android studio. That fixed the cache issue of course also.

Incorect Daemon Configuration [duplicate]

Version of Android Studio (Beta) 0.8.4
OS version: Windows 8
Java JRE/JDK version: 1.8.0_11
Error:Unable to start the daemon process.
This problem might be caused by incorrect configuration of the daemon.
For example, an unrecognized jvm option is used.
Please refer to the user guide chapter on the daemon at http://gradle.org/docs/1.12/userguide/gradle_daemon.html
-----------------------
Error occurred during initialization of VM
Could not reserve enough space for 1048576KB object heap
Java HotSpot(TM) Client VM warning: ignoring option MaxPermSize=256m; support was removed in 8.0

The Solution Worked:
1.Open the projects gradle.properties file in android studio
2.Added this line at end of file org.gradle.jvmargs=-Xmx1024m & Save the file
3.Close & reopen the project or just Clean and re-Build it

Do Following steps:
Start Android Studio.
Close any open project.Go to File > Close Project.(Welcome window will open)
Go to Configure > Settings.
On Settings dialog,select Compiler (Gradle-based Android
Projects) from left and set VM Options to -Xmx512m(i.e. write -Xmx512m
under VM Options:) and press OK.

I had the same issue, it was because I had an existing ".gradle" folder and then I've played with the android studio version (and also with the Java jdk version) , and I guess it messed things up.
Solution: Remove the .gradle directory (mine's location was C:\Users\UserName\.gradle), and restart android studio. It will automatically create a new one.

For android studio 2.2 version VM option is not available directly from project structure.
steps to make gradle sync successful:->
1)OPEN project
2)Click on gradle script
3)open gradle.properties
4)Change org.gradle.jvmargs=-Xmx1536m to org.gradle.jvmargs=-Xmx1024m
5)Save the work
6)Open File->Invalidate cache/Restart
And its done!!!
Enjoy Android!!!

Open your project and press Ctrl + Alt + Shift + S to open Project Structure. There under JDK location check Use embedded JDK (recommended).

Just reboot your PC
Not sure what caused this issue for me, I've tried all the solutions here, nothing worked.
Reboot helped, Windows 7.
org.gradle.jvmargs=-Xmx2048m was already there.
Update:
I believe it started after Update of Windows Defender Antivirus (KB915597)
Approximate date of update - 2018.07.22

It has to do with how much memory is available for AS to create a VM environment for your app to populate. The thing is that ever since the update to 2.2 I've had the same problem every time I try to create a new project in AS.
How I solve it is by going into Project (on the left hand side) > Gradle Scripts > gradle.properties. When it opens the file go to the line under "(Line 10)# Specifies the JVM arguments used for the daemon process. (Line 11)# The setting is particularly useful for tweaking memory settings." You're looking for the line that starts with "org.gradle.jvmargs". This should be line 12. Change line 12 to this
org.gradle.jvmargs=-Xmx2048m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
After changing this line you can either sync the gradle with the project by clicking Try again on the notification telling you the gradle sync failed (it'll be at the top of the file you opened). Or you can simply close and restart the AS and it should sync.
Essentially what this is saying is for AS to allocate more memory to the app initialization. I know it's not a permanent fix but it should get you through actually starting your app.

I had the same problem. Starting Android Studio as Administrator fixed it.

Open Android Studio then go to gradle.properties file and change the last line to
org.gradle.jvmargs=-Xmx1024m.
And then press try again

Open Android Studio then go to gradle.properties file and change the last line to
org.gradle.jvmargs=-Xmx1024m.
then go to
File>Invalidate Caches/Restart.
and the problem will be solved, it worked fine with me.

the heap-size was already set in project and also android studio.
still, had this issue.
this issue is related to memory size.
here is what solved my issue:
open "task management" in windows(ctrl + shift + esc)
check, whether any program is eating memory.
please scroll down
(first time i just saw according to descending order of memory usage. but scrolled after trying other options and realised, "openjdk platform binary" consumed around 50mb but was running around more than 50 instances.)
end all the instances and check whether it solves the issue.
if "yes", update java so that, starting all these multiple instance entries are wiped out of registry.
if "no", try following:
additional solutions (if heap-size was already set):
uninstall any lastly (recently) installed plugin.
if you want the plugin (search for plugin related issue).
File>Invalidate caches / restart...
update gradle.
uninstall android studio and install a fresh new one (after File>Manage IDE settings>Export to ZIP files).

In some PC's this issue is caused by antivirus programs AFTER upgrading to the latest android studio and gradle version.
In my case I tore my system apart troubleshooting everything only to find out that Commodo Internet security was responsible for not letting the gradle daemon run.
After safelisting the process everything runs smoothly.
PLEASE NOTE that everything was OK before updating. The issue came up only after the update without changing anything in the antivirus/firewall program.

I had the same issue , i just remove .gradle file and restart android studio, it automatically download latest version and it works perfect.....

Try adding -Xmx512m in Android Studio->Settings->Compiler->VM Options as in below image.
Reason for this issue could be: Grade's build daemon ( forked process ) is invoked with maximum Java heap size as platform default value. On a 32 bit Windows this system this could be as high as 1GB. We get this error message, if that much(default) heap size cannot be allocated to the build deamon. So use the -Xmx option to set a lower heap size. It is not necessary to stick to -Xmx<size> with size as 512m. In my Win 32bit, 4GB RAM machine, -Xmx768m was also good enough.

I had the same problem, what i found was that Android Developer tools doesn't work well with JDK 8.
I deleted my current JDK 8 and and installed JDK 7 and worked just like that no increase of heap memory or delete of .gradle folder.

Believe it or not, I just encountered this sudden problem after performing a Windows Update on Windows 10. Somehow, that update messed up my existing Malwarebytes Anti-Exploit program, and ultimately caused Android Studio to be unable to invoke the JVM (I couldn't even open cmd.exe!).
Solution was to remove the Malwarebytes Anti-Exploit program (this may be fixed in the future).

I got same problem and I solved it using these steps.
1)Remove your .gradle file.(uuslly it in C:\Users{your_PC_name}
2)then go to the environment variable and add these to the system variable(as a new variable)
Variable name : _JAVA_OPTIONS
Variable value: -Xmx524m
3)go to your project folder and run these command
ionic cordova platform add android
4)Above command create platform folder in your project path
5)then run this command
ionic cordova build android

I've just cleaned up my disk space and restart computer. That have helped me.

Error occurred during initialization of VM Could not reserve enough space for 1572864KB object heap.
To solve this error you have to change only heap size which is defined in Gradle.Properties file. You have to change the heapsize to 1024m and rebuild the project.
If the error is not solved, you have to close the project and rebuild it.
For Video Tutorial: Unable To Start The Daemon Process In Android Studio

Different solutions may work
Delete .gradle folder from c:\users\username\.gradle
File > Settings.
On Settings dialog, select Compiler (Gradle-based Android Projects) from left and set VM Options to -Xmx512m (i.e. write -Xmx512m under VM Options:) and press OK.
Close multiple applications running on your machine and clear memory space and try again

Start Android Studio.
Close any open project.Go to File > Close Project.(Welcome window will open)
Go to Configure > Settings.
On Settings dialog,select Compiler (Gradle-based Android Projects) from left and set VM Options to -Xmx512m(i.e. write -Xmx512m under VM Options:) and press OK.
It mostly works for that initilize vm problem.

Start Android Studio.
Close any open project.Go to File > Close Project.(Welcome window will open)
Go to Configure > Settings.
On Settings dialog,select Compiler (Gradle-based Android Projects) from left and set VM Options to -Xmx512m(i.e. write -Xmx512m under VM Options:) and press OK.
and then do this
Right click on My Computer and Open up your System Properties (The bit you had open before that shows your CPU/RAM values) >> On the left sidebar, click Advanced System Settings >> Click Environment Variables >> Under System Variables, press New >> Use the values below: // Variable name: _JAVA_OPTIONS // Variable value: -Xmx524M then, press OK and try again. restart Android Studio

Try disabling firewall.
This might be a very weird solution but I had the same problem and I'm running Android 2.3 on windows 32 bit . I deleted the current app and disabled firewall. Upon creating a new project everything worked fine.

If i can help you, you have to go in the Project Properties, and in the JDK location field check Use embedded JSD (recommended) eneable.

You need to add the path to environment variables (Windows) like such:
Variable Name: GRADLE_HOME
Variable Value: path
Please check below image:

try to adding -Xmx512m in Android Studio->Settings->Compiler->VM Options , it's working thanks..

In the gradle.properties file, change org.gradle.jvmargs to -Xmx1024m:
org.gradle.jvmargs=**-Xmx1024m** -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8

My case is a bit special which VM option is not avaibale. I use x86 windows 7 system, my way of solving this problem is by doing following procedures:
File - Setting...
In "Build, Execution, Deployment" select "Gradle"
choose "Use default gradle wrapper (recommended)" in "Project-level settings"
After restart Android Studio problem fixed!

I think if your environment just got messed up because of some VCS merging or commit errors, which is my case, i would suggest you just re-import your porject and add it to the root of your VCS to restore the project. If you use a VCS like git or subversion, you'll simply have to add your project to the root of the given repo and everything should be back to normal.
This worked for me though.

I fixed this issue by installing JDK x64. I guess you're using jdk x86 and it's not enough memory for gradle.

not enough memory to perform requested operation-Android studio Out of memory issue [duplicate]

I've been using Android Studio for 3 months now and one of the apps I started on it has become fairly large. The memory usage indicated at the bottom right of the program says my allocated heap is maxed at 494M.
When I start to change the XML files my memory usage quickly reaches that cap and the IDE crashes with an Out Of Memory error like this.
I've tried to increase the heap size using this but so far there has been no effect.
I've looked at dozens of articles and other questions on how to increase the heap size but none of their answers are working. No matter what I do to the VMOPTIONS or the IDE settings the heap size never increases. I believe I am editting the correct file for the VMOPTIONS because if I purposely give it an invalid command Android Studio complains about it and doesn't start.
I'm using windows 7 - 64 bit and have 16GB RAM.
Has anyone else had this problem with Android Studio? And were you able to fix it?

-------EDIT--------
Android Studio 2.0 and above, you can create/edit this file by accessing "Edit Custom VM Options" from the Help menu.
-------ORIGINAL ANSWER--------
Open file located at
/Applications/Android\ Studio.app/Contents/bin/studio.vmoptions
Change the content to
-Xms128m
-Xmx4096m
-XX:MaxPermSize=1024m
-XX:ReservedCodeCacheSize=200m
-XX:+UseCompressedOops
Xmx specifies the maximum memory allocation pool for a Java Virtual Machine (JVM), while Xms specifies the initial memory allocation pool. Your JVM will be started with Xms amount of memory and will be able to use a maximum of Xmx amount of memory.
Save the studio.vmoptions file and restart Android Studio.
Note:
If you changed the heap size for the IDE, you must restart Android Studio before the new memory settings are applied. (source)

I looked at my Environment Variables and had a System Variable called _JAVA_OPTIONS with the value -Xms256m -Xmx512m, after changing this to -Xms256m -Xmx1024m the max heap size increased accordingly.

Or, you can go to your android-studio\bin folder and change these -Xmx and -Xms values in studio.exe.vmoptions or studio64.exe.vmoptions files (depending on which version you are running).

You should not edit any files in the IDE installation directory. Instead, you can customize the attributes by creating your own .properties or .vmoptions files in the following directories. (This has been possible on some platforms before, but it required you to copy and change the entire contents of the files. With the latest changes these properties are now additive instead such that you can set just the attributes you care about, and the rest will use the defaults from the IDE installation).
Note: As of Android Studio 2.0, you can create/edit this file by accessing the "Edit Custom VM Options" file from the Help menu.
http://tools.android.com/tech-docs/configuration

I increased my memory following the next Google documentation:
http://tools.android.com/tech-docs/configuration
By default Android Studio is assigned a max of 750Mb, I changed to 2048Mb.
I tried what google described but for me the only thing that it worked was to use an environment variable. I will describe what I did:
First I created a directory that I called .AndroidStudioSettings,
mkdir .AndroidStudioSettings
Then I created a file called studio.vmoptions , and I put in that file the following content:
-Xms256m
-Xmx2048m
-XX:MaxPermSize=512m
-XX:ReservedCodeCacheSize=128m
-XX:+UseCompressedOops
Then I added the STUDIO_VM_OPTIONS environment variables in my .profile file:
export STUDIO_VM_OPTIONS=/Users/youruser/.AndroidStudioSettings/studio.vmoptions
Then I reload my .profile:
source ~/.profile
And finally I open Android Studio:
open /Applications/Android\ Studio.app
And now as you can see using the status bar , I have more than 2000 MB available for Android Studio:
You can customize your values according to your need in my case 2048Mb is enough.
UPDATE : Android Studio 2.0 let's you modify this file by accessing "Edit Custom VM Options" from the Help menu, just copy and paste the variables you might want to keep in order to increase it for everversion you might have on your box.

If you are using MAC BOOK, this option is available inside Applications -> Right click Android Studio then choose Show Package contents -> bin.
or
open -e /Applications/Android\ Studio.app/Contents/bin/studio.vmoptions
Then increase Xmx value
-Xms128m
-Xmx2048m
-XX:MaxPermSize=350m
-XX:ReservedCodeCacheSize=64m
-XX:+UseCodeCacheFlushing
-XX:+UseCompressedOops
Now your Android Studio will be super-fast.

Android Studio 3.1 has option to edit your customize virtual memory options.
You can go Android Studio > Help > Edit Custom VM Options
Then paste below settings code to studio64.exe.vmoptions file & Save it.
file location : "\Users\username\.AndroidStudio3.**\config\"
-Xms128m
-Xmx4096m
-XX:MaxPermSize=1024m
-XX:ReservedCodeCacheSize=200m
-XX:+UseCompressedOops

You can try any one of the following
1)Change the gradle.properties file and change the heap size as per your requirement.
If org.gradle.jvmargs=-Xmx2048M is not sufficient then change to 4096 as given
org.gradle.jvmargs=-Xmx4096M
2)"Edit Custom VM Options" from the Help menu.
It will open studio.vmoptions / studio64.exe.vmoptions file.
Change the content to
-Xms128m
-Xmx4096m
-XX:MaxPermSize=1024m
-XX:ReservedCodeCacheSize=200m
-XX:+UseCompressedOops
Save the the file and restart Android Studio.

Note: I now this is not the answer for the post, but maybe this will be helpful for some one that is looking.
If Nothing of this works for you, try on a Mac this to see if helps you, in the last version of Android Studio, the studio.vmoptions is inside the AndroidStudio.app in your Applications folder.
So right click or ctrl click on your AndroidStudio.App and then select show package content the studio.vmoptions is in:
Contents/bin/studio.vmoptions
Replace or change it and you will get all the RAM you need.
Regards.

I tried the _JAVA_OPTIONS thing but it wasn't working for me still.
In the end, what worked for me was the following:
Launching studio64.exe instead of the studio.exe(I've got a 64-bits machine).
Add/Change the following values in "studio64.exe.vmoptions":
-Xms2048m
-Xmx2048m
-XX:MaxPermSize=1024m
-XX:+CMSClassUnloadingEnabled
-XX:+CMSPermGenSweepingEnabled
-XX:+HeapDumpOnOutOfMemoryError
-Dfile.encoding=utf-8

There are a lot of answers that are now outdated. The desired way of changing the heap size for Android Studio recently changed.
Users should now create their own vmoptions file in one of the following directories;
Windows:
%USERPROFILE%\.{FOLDER_NAME}\studio64.exe.vmoptions
Mac:
~/Library/Preferences/{FOLDER_NAME}/studio.vmoptions
Linux:
~/.{FOLDER_NAME}/studio.vmoptions and/or ~/.{FOLDER_NAME}/studio64.vmoptions
The contents of the newly created *.vmoptions file should be:
-Xms128m
-Xmx750m
-XX:MaxPermSize=350m
-XX:ReservedCodeCacheSize=96m
-XX:+UseCompressedOops
To increase the RAM allotment change -XmX750m to another value.
Full instructions can be found here:
http://tools.android.com/tech-docs/configuration

First check how much memory allocated for your android studio
to check that follow this steps :
File -> Settings->Appearance & Behavior->Appearance
then check the show memory indicator option like below image red highlighted part
In my case my RAM is 12Gb so i have allocated memory for android studio 6gb .To edit that follow this steps
Help->Edit custom VM options
-Xmx6g
In my case, i have set it 6gb because my pc ram is 12 GB. Its upto you how much memory you want to allocate to your android studio

This is how you change the heap size currently in Android Studio 3.6.1
On Windows in your Android Studio:
Select File -> Settings (the popup below will be displayed)
Select Appearance & Behavior
Select System Settings
Select Memory Settings
Then change the IDE Heap Size settings to your desired value
On Mac:
Select Android Studio
Select Preferences
The same pop up will appear. However, this time on the Mac its called Preferences.
Follow the same steps as the Windows version of Android Studio to adjust the heap size wants the Preferences dialog has been displayed

On Mac OSX one can easily change heap size by going to first menu item, Android Studio > preference > System Settings (left menu) > Memory Settings and change heap size there in the dialog.

On Windows 7, the configuration files at [INSTALL-LOCATION]\bin seem to be ignored. Per the following Google documentation, the file to be modified should be here: %USERPROFILE%\.AndroidStudio\studio[64].exe.vmoptions
http://tools.android.com/tech-docs/configuration
Odd that there is no such file upon a clean install of Android Studio 1.1 from the developer site. And they are in the old (ignored) location. Once I copy the file (studio.exe.vmoptions in my case) over and modify it, the change is respected.
However, the fun doesn't stop there. There's an upper value for -Xmx which may be related to the amount of memory in your system. I just bumped my machine's memory from 4Gb to 16Gb, and assumed I could set -Xmx to 2048m, but I found that if I set it to anything larger than 1500m, Android Studio would silently fail to launch with no indication at all as to why. I have more RAM on the way, so it will be interesting to see if I can increase the value at that point.
I hope this additional information is helpful. While all of the above replies were undoubtedly true at one point (and may still be in some environments), I found that this was the only approach that increased the memory used by AS for me.

Open studio.vmoptions and change JVM options
studio.vmoptions locates at /Applications/Android\ Studio.app/bin/studio.vmoptions (Mac OS). In my machine, it looks like
-Xms128m
-Xmx800m
-XX:MaxPermSize=350m
-XX:ReservedCodeCacheSize=64m
-XX:+UseCodeCacheFlushing
-XX:+UseCompressedOops
Change to
-Xms256m
-Xmx1024m
-XX:MaxPermSize=350m
-XX:ReservedCodeCacheSize=64m
-XX:+UseCodeCacheFlushing
-XX:+UseCompressedOops
And restart Android Studio
See more Android Studio website

I found on on Windows 7/8 (64-bit), as of Android Studio 1.1.0:
[INSTALL_DIR]\bin\studio64.exe.vmoptions be used (if it exists), otherwise it would always fall back to %USERPROFILE%.\AndroidStudio\studio[64].exe.vmoptions
If you want the settings managed from %USERPROFILE%.\AndroidStudio\studio[64].exe.vmoptions, just delete the one in the installation directory.

Go in the Gradle Scripts -> local.properties and paste this
`org.gradle.jvmargs=-XX\:MaxHeapSize\=512m -Xmx512m`
, if you want to change it to 512. Hope it works !

you are not supposed to modify the bin/studio.exe.vmoptions file, which will be verified during applying update patch.
Solutions are here http://tools.android.com/tech-docs/configuration
copy that file into following location, then change the -Xmx1280m to whatever you want.
Windows:
%USERPROFILE%\.{FOLDER_NAME}\studio.exe.vmoptions
and/or
%USERPROFILE%\.{FOLDER_NAME}\studio64.exe.vmoptions
%USERPROFILE%\.{FOLDER_NAME}\idea.properties
Mac:
~/Library/Preferences/{FOLDER_NAME}/studio.vmoptions
~/Library/Preferences/{FOLDER_NAME}/idea.properties
Linux:
~/.{FOLDER_NAME}/studio.vmoptions
and/or
~/.{FOLDER_NAME}/studio64.vmoptions
~/.{FOLDER_NAME}/idea.properties

Had this Xms and Xmx memory low issue happen to me any time I was working with the XML. I also tried increasing this memory, only to find that it just took a little longer for it to happen again.
After getting very frustrated and almost deciding to convert all my current projects back over to Eclipse, which I did not want to do, I figured out what was causing it and was able to repeat this failure and prevent it every time.
While editing the XML in (Text view), and using the "Preview" render view, this causes the loss of memory, every time. Turning off "Preview" and using the Design tab to render the screen only, I am able to use Android Studio all day long, with no crash.
I wish this could be fixed for good, because it would be very nice to use the "Preview" render while editing the XML, however I am glad I can keep using Android Studio.

On Ubuntu, it's straight forward, clicking Help > Edit Custom VM Options
. The IDE asks whether to create for you a file, click OK.
An empty studio64.vmoptions file is create and paste the following variables:
-Xms128m
-Xmx4096m
-XX:MaxPermSize=1024m
-XX:ReservedCodeCacheSize=200m
-XX:+UseCompressedOops
Restart the IDE, the Max Heap Size is increased to: 4,062M

May help someone that get this problem:
I edit studio64.exe.vmoptions file, but failed to save.
So I opened this file with Notepad++ in Run as Administrator mode and then saved successfully.

IF by changing or creating the .studio.exe.vmoptions doesn't work, then try changing the gradle.properties file and change the heap size as per your requirement.
It really worked for me on my Windows 7 with 4Gb RAM and Android Studio 2.2 install on it.
Working properly with no error and displaying 'Gradle Sync complete'

-Xms256m
-Xmx2048m
-XX:MaxPermSize=512m
-XX:ReservedCodeCacheSize=128m
-XX:+UseCompressedOops

As of 2022, you may check this link here.
https://developer.android.com/studio/intro/studio-config.html
Windows
Syntax: %APPDATA%\Google\<product><version>
Example: C:\Users\YourUserName\AppData\Roaming\Google\AndroidStudio4.1
macOS
Syntax: ~/Library/Application Support/Google/<product><version>
Example: ~/Library/Application Support/Google/AndroidStudio4.1

Android studio 2.2.3 is too slow when it starts

Android studio is too slow when it starts. It is needed to wait few minutes before the loading pops up. I'm not talking about the gradle building, but android itself...
This is not my first android studio... I also used android studio(maybe 2.2.1 or 2.2.0) before I formatted my laptop, thus I know how much time it needs to show that loading screen.
For details I use 6th generation I5 cpu, 8GB Ram, and ssd.

You need to upgrade your PC though but there are few things you can do to make it faster
Increase the memory size of Android Studio:**
Open the file located at /bin/studio.vmoptions and Change the content from
-Xms128m
-Xmx800m
to
-Xms256m
-Xmx1024m
Xms specifies the initial memory allocation pool. Your JVM will be started with Xms amount of memory and will be able to use a maximum of Xmx amount of memory.
Save the studio.vmoptions file and restart Android Studio.
Improve Gradle performance:**
Create a file named gradle.properties in
/home/<username>/.gradle/ (Linux)
/Users/<username>/.gradle/ (Mac)
C:\Users\<username>\.gradle (Windows)
and add the line:
org.gradle.daemon=true
This helps a lot, with org.gradle.daemon set to true Gradle reuses computations from previous builds and cache information about project structure, files, tasks etc. in memory so it won’t have to start up the entire Gradle application every time.

In order to increase the speed of the android studio you need to allocated extra RAM memory to android studio(Vm option) as mentioned in the link ---> config android studio vm option.In the official blog it state that you can not edit it directly.
Note that you should never directly edit the studio.vmoptions file found inside the Android Studio program folder. While you can access the file to view Studio's default VM options, editing only your own studio.vmoptions file ensures that you don't override important default settings for Android Studio. Therefore, in your studio.vmoptions file, override only the attributes you care about and allow Android Studio to continue using default values for any attributes you have not changed

Getting Gradle error "Could not reserve enough space for object heap" constantly in Intellij IDEA

So I have a problem with memory allocation. Sometimes it works, and sometimes it doesn't. I've read this thread and tried the advice there multiple times. Sometimes -Xms512m -Xmx768m works, sometimes -Xms256m -Xmx512m. I'm sick and tired of having to tweak this setting in IntelliJ under the Build, Execution, Deployment > Build Tools > Gradle > Gradle VM options setting. Is there no setting that solves this once and for all?
I have 16GB of RAM on my Windows 7 computer, I'm running IntelliJ IDEA EAP 14 build 138.2210.3, 64 bit version. Android Gradle build plugin v0.12.
I'm suspecting gradle is not running in 64 bit mode, or else it would have ~7 GB of free memory to eat from. Why is it not utilizing this?
EDIT:
I got the same error in Visual Studio 2015 with cordova 5.1.1 under Windows 10.
See my solution below.

I got the same error in Visual Studio 2015 with cordova 5.1.1 under Windows 10.
To solve the issue, set this environment variable:
_JAVA_OPTIONS=-Xmx512M
Right click on start-button and open "System"
Search for "Advanced system settings" and open it
Click the button "Environment Variables ..."
In System Variables, click "New..."
New Variable Name: _JAVA_OPTIONS
New Variable Value: -Xmx512M
Click OK
Restart Visual Studio, so the variable is picked up
This Article point me in the right direction. I did change the instructions a littel bit, so they fits to Windows 10.
Hope it helps someone!

Installing 64 bit Java solved it for me

Although this question is a bit older I would like to come up with the (possible) rootcause of the problem: the JVM requests a whole block of memory on startup. If it couldn't find it, the "Could not reserve..." error occurs. John Pape wrote an enlighting article in IBM's devblog about this issue: https://www.ibm.com/developerworks/community/blogs/aimsupport/entry/why_wont_my_jvm_start_with_this_heap_size?lang=en
This is solving the problem for me:
variant a: using a 64 bit version of Java, so to give Java a bigger area of possible connected free memory
variant b: With 32 bit Java using smaller XMX amount. In the gradle.properties file I just use org.gradle.jvmargs=-Xmx150m and Gradle has no problems.

This happens to me too and it drives me nuts. It could be that the memory (ram) available is fragmented. Although you have enough free memory, there is no contiguous 512MB blocks available, it's all fragmented into smaller blocks! This is why you only see it "sometimes".
Some things worth trying:
check if you're low on memory, try to close other apps. This happens to me sometimes even if I still have a good 3GB free out of my 8GB! That 3GB can be fragmented in blocks which are all smaller than 512MB [ex: if you have -Xmx512m]... Rebooting is a way to defrag your memory. Or close firefox, that'll free up a gig ;-)
also, surprisingly, check your swap space [free disk space]! Depends of machine/JVM/etc implementation. But if you're low on swap space and your memory is fragmented, that could be another cause.
lower your -Xmx to maybe -Xms128m -Xmx512m to make it easier to find a contiguous block of free memory [128m]. This might not be a good idea if gradle truly needs 512m minimum. Given that we're talking about gradle, ignore this bullet point (could be a useful tip for other cases/worth noting).
double check your Xms/Xmx in ~/.gradle/gradle.properties attribute: org.gradle.jvmargs
use idea64.exe [64bit] and if you think IDEA is using the wrong JDK [32bit], in latest Intellij IDEA [14.1.3 as of this writting], go to "Settings"->"Build,Execution,Deployment" -> "Gradle": "use the default wrapper" and select the Gradle JVM you'd like (if you think it uses the wrong one, you'll see it here".
finally, this is just a guess but: in the previous bullet, I wonder if you select "use project JDK", if that makes it easier to find contiguous memory. I'm not sure if that means that Gradle will use intellij IDEA's already reserved memory block. So, instead of having two processes, you only have one and you could reserve a bigger memory block when IDEA starts up. But I'm not sure if that's accurate of if that's an option to suggest to Intellij...
I agree with you, I've never had any memory issues with IDEA [well no issues AT ALL] until gradle integration came along.

In your android folder there is a gradel.properties file and add the following lines:
org.gradle.jvmargs=-XX\:MaxHeapSize\=256m -Xmx256m
I ran into this while using Intellij and Flutter. Also another property you may find useful to add is declaring where the JDK is.
org.gradle.java.home=C:\\Your\\JDK\\path

follow these steps:
1° Install Java SDK - 64bits or 32bits
https://www.oracle.com/br/java/technologies/javase/javase-jdk8-downloads.html
2° configure the envriment variable
Windows 10 -
2.1° - control panel -> system and security -> advanced system settings -> envriment variable
2.2° - in environment variables, you need to add the path of the SDK you installed:
windows 32bits click add -> name of variable: JAVA_HOME value of variable: C:\Program Files(x86)\Java\jdk1.8.0_291
windows 64bits click add -> name of variable: JAVA_HOME value of variable: C:\Program Files\Java\jdk1.8.0_291
after following these steps, you should be able to run normally.

In my case I had too much things opened. Freeing memory made it work.