blocks|key|2996797|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2996798|安卓应用程序(不是系统应用程序)可以使用的最大内存量(以is为单位/占内存总量的百分比)是多少？|blockquote|2996799|2996800|2996801|这一点因设备而异。getMemoryClass()+on+ActivityManager将为您提供运行代码的设备的值。|offset|length|style|CODE|2996802|2996803|安卓版本之间有什么不同吗？|2996804|2996805|2996806|是的，多年来操作系统需求不断增加，设备必须进行调整以与之匹配。|2996807|2996808|设备的制造商有什么不同？|2996809|2996810|2996811|是的，就制造商制造设备而言，其大小因设备而异。|2996812|2996813|在确定应用程序可以使用多少内存时，需要考虑哪些“辅助因素”？|2996814|2996815|2996816|我不知道“副作用”是什么意思。|2996817|2996818|早期的设备每个应用程序的上限为16MB；后来的设备将其提高到24MB或32MB|2996819|2996820|2996821|这就对了。屏幕分辨率是一个重要的决定因素，因为更大的分辨率意味着更大的位图，因此平板电脑和高分辨率手机往往会有更高的值。例如，您将看到具有48MB堆的设备，如果有更高的值，我不会感到惊讶。|2996822|2996823|应用程序怎么可能超过这个限制呢？|2996824|2996825|2996826|你假设应用程序的作者知道他在做什么。考虑到memory+usage+of+an+app+is+difficult+for+a+core+Android+engineer+to+determine，我不会假设有问题的应用程序一定会提供特别准确的结果。|2996827|也就是说，本机代码(NDK)不受堆限制。而且，从Android3.0开始，应用程序可以请求“大堆”，通常在数百MB的范围内，但对于大多数应用程序来说，这被认为是糟糕的形式。|2996828|2996829|此外，我注意到我的一些应用程序在使用大约30-40兆字节的OutOfMemoryException时崩溃。|2996830|2996831|2996832|请记住，Android垃圾收集器不是紧凑型垃圾收集器。真正的例外应该是CouldNotFindSufficientlyLargeBlockOfMemoryException，但这可能被认为太冗长了。OutOfMemoryException意味着你的不能分配你请求的块，而不是你已经完全耗尽了你的堆。|BOLD|2996833|entityMap|0|LINK|mutability|MUTABLE|url|http://developer.android.com/reference/android/app/ActivityManager.html#getMemoryClass%2528%2529|1|https://stackoverflow.com/questions/2298208/how-to-discover-memory-usage-of-my-application-in-android/2299813#2299813^0|0|0|0|0|9|G|T|F|9|Z|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|L|24|1|0|0|0|0|0|0|Z|1F|2R|K|3G|9|0^^$0|@$1|2|3|-4|4|5|6|24|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|25|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|26|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|27|7|@]|8|@]|9|$]]|$1|F|3|G|4|5|6|28|7|@$H|29|I|2A|J|K]|$H|2B|I|2C|J|K]]|8|@$H|2D|I|2E|1|2F]]|9|$]]|$1|L|3|-4|4|5|6|2G|7|@]|8|@]|9|$]]|$1|M|3|N|4|C|6|2H|7|@]|8|@]|9|$]]|$1|O|3|-4|4|5|6|2I|7|@]|8|@]|9|$]]|$1|P|3|-4|4|5|6|2J|7|@]|8|@]|9|$]]|$1|Q|3|R|4|5|6|2K|7|@]|8|@]|9|$]]|$1|S|3|-4|4|5|6|2L|7|@]|8|@]|9|$]]|$1|T|3|U|4|C|6|2M|7|@]|8|@]|9|$]]|$1|V|3|-4|4|5|6|2N|7|@]|8|@]|9|$]]|$1|W|3|-4|4|5|6|2O|7|@]|8|@]|9|$]]|$1|X|3|Y|4|5|6|2P|7|@]|8|@]|9|$]]|$1|Z|3|-4|4|5|6|2Q|7|@]|8|@]|9|$]]|$1|10|3|11|4|C|6|2R|7|@]|8|@]|9|$]]|$1|12|3|-4|4|5|6|2S|7|@]|8|@]|9|$]]|$1|13|3|-4|4|5|6|2T|7|@]|8|@]|9|$]]|$1|14|3|15|4|5|6|2U|7|@]|8|@]|9|$]]|$1|16|3|-4|4|5|6|2V|7|@]|8|@]|9|$]]|$1|17|3|18|4|C|6|2W|7|@]|8|@]|9|$]]|$1|19|3|-4|4|5|6|2X|7|@]|8|@]|9|$]]|$1|1A|3|-4|4|5|6|2Y|7|@]|8|@]|9|$]]|$1|1B|3|1C|4|5|6|2Z|7|@]|8|@]|9|$]]|$1|1D|3|-4|4|5|6|30|7|@]|8|@]|9|$]]|$1|1E|3|1F|4|C|6|31|7|@]|8|@]|9|$]]|$1|1G|3|-4|4|5|6|32|7|@]|8|@]|9|$]]|$1|1H|3|-4|4|5|6|33|7|@]|8|@]|9|$]]|$1|1I|3|1J|4|5|6|34|7|@]|8|@$H|35|I|36|1|37]]|9|$]]|$1|1K|3|1L|4|5|6|38|7|@]|8|@]|9|$]]|$1|1M|3|-4|4|5|6|39|7|@]|8|@]|9|$]]|$1|1N|3|1O|4|C|6|3A|7|@]|8|@]|9|$]]|$1|1P|3|-4|4|5|6|3B|7|@]|8|@]|9|$]]|$1|1Q|3|-4|4|5|6|3C|7|@]|8|@]|9|$]]|$1|1R|3|1S|4|5|6|3D|7|@$H|3E|I|3F|J|K]|$H|3G|I|3H|J|K]|$H|3I|I|3J|J|1T]]|8|@]|9|$]]|$1|1U|3|-4|4|5|6|3K|7|@]|8|@]|9|$]]]|1V|$1W|$4|1X|1Y|1Z|9|$20|21]]|22|$4|1X|1Y|1Z|9|$20|23]]]]

<blockquote>
 What is the maximum amount of memory (in Megabytes / as percentage of the total RAM) that an Android application (that is not a system app) can use?
</blockquote>

That varies by device. <a href="http://developer.android.com/reference/android/app/ActivityManager.html#getMemoryClass%28%29" rel="noreferrer"><code>getMemoryClass()</code> on <code>ActivityManager</code></a> will give you the value for the device your code is running upon.

<blockquote>
 Are there any differences between the Android versions?
</blockquote>

Yes, insofar as OS requirements have increased over the years, and devices have to adjust to match.

<blockquote>
 Are there differences concerning the manufacturer of the device?
</blockquote>

Yes, insofar as manufacturers manufacture devices, and the size varies by device.

<blockquote>
 Which "side factors" are taken into consideration when it comes to determining how much RAM an app can use?
</blockquote>

I have no idea what "side factors" means.

<blockquote>
 Early devices had a per-app cap of 16MB; Later devices increased that to 24MB or 32MB
</blockquote>

That's about right. Screen resolution is a significant determinant, as larger resolutions mean larger bitmaps, and so tablets and high-resolution phones will tend to have higher values yet. For example, you will see devices with 48MB heaps, and I wouldn't be surprised if there are values higher than that.

<blockquote>
 How is it possible that apps exceed that limit?
</blockquote>

You assume that the author of that app knows what (s)he is doing. Considering that <a href="https://stackoverflow.com/questions/2298208/how-to-discover-memory-usage-of-my-application-in-android/2299813#2299813">memory usage of an app is difficult for a core Android engineer to determine</a>, I would not assume that the app in question is necessarily providing particularly accurate results.

That being said, native code (NDK) is not subject to the heap limit. And, since Android 3.0, apps can request a "large heap", usually in the hundreds of MB range, but that's considered poor form for most apps.

<blockquote>
 Furthermore, I noticed that some apps of mine crash with an OutOfMemoryException when using around 30-40 Megabytes.
</blockquote>

Bear in mind that the Android garbage collector is not a compacting garbage collector. The exception really should be <code>CouldNotFindSufficientlyLargeBlockOfMemoryException</code>, but that was probably deemed too wordy. <code>OutOfMemoryException</code> means that you could not allocate your requested block, not that you have exhausted your heap entirely.

blocks|key|176577|text|根据屏幕大小和安卓版本，每个应用程序的内存限制如下：https://drive.google.com/file/d/0B7Vx1OvzrLa3Y0R0X1BZbUpicGc/view?usp=sharing|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|176578|来源:安卓兼容性下载http://source.android.com/compatibility/downloads.html；兼容性定义文档(CDD)，部分虚拟机兼容性或运行时兼容性|176579|entityMap|0|LINK|mutability|MUTABLE|url|https://drive.google.com/file/d/0B7Vx1OvzrLa3Y0R0X1BZbUpicGc/view?usp=sharing|1|http://source.android.com/compatibility/downloads.html^0|Q|25|0|0|A|1I|1|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]]|C|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@$A|U|B|V|1|W]]|C|$]]|$1|F|3|-4|5|6|7|X|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]|N|$5|I|J|K|C|$L|O]]]]

Memory limits per app are here depending on screen size and Android version: <a href="https://drive.google.com/file/d/0B7Vx1OvzrLa3Y0R0X1BZbUpicGc/view?usp=sharing" rel="noreferrer">https://drive.google.com/file/d/0B7Vx1OvzrLa3Y0R0X1BZbUpicGc/view?usp=sharing</a>

Source: Android Compatibility Downloads <a href="http://source.android.com/compatibility/downloads.html" rel="noreferrer">http://source.android.com/compatibility/downloads.html</a>; 
Compatibility Definition Document (CDD), Section Virtual Machine Compatibility or Runtime Compatibility

blocks|key|179140|text|现在是2018年年底，所以情况发生了变化。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|179141|首先:运行你的应用程序并在Android+Studio中打开Android+Profiler选项卡。你会看到它消耗了多少内存，你会感到惊讶，但它可以分配大量的RAM。|179142|此外，官方文档中的here+is+a+great+article提供了有关如何使用内存分析器的详细说明，这可以让您深入了解内存管理。|offset|length|179143|但在大多数情况下，你常规的Android+Profiler就足够了。|179144|​|179145|📷|atomic|179146|179147|通常，一个应用程序一开始会分配50Mb的内存，但当你开始在内存中加载一些照片时，它会立即跳到90Mb。当你用预加载照片(每张3.5Mb)的ViewPager打开Activity时，你可以在几秒钟内轻松获得190Mb。|179148|但这并不意味着你在内存管理方面有问题。|179149|我能给出的最好的建议是遵循指南和最佳实践，使用顶尖的库来加载图像(Glide，Picasso)，你就可以了。|179150|179151|但是，如果你需要定制一些东西，并且你真的需要知道你可以手动分配多少内存，你可以获得总的空闲内存，并从中计算出预定的部分(以%25为单位)。在我的例子中，我需要在内存中缓存解密的照片，这样我就不需要每次用户在列表中滑动时都解密它们。|179152|为此，您可以使用ready+to+use+LruCache+class。它是一个缓存类，可以自动跟踪你的对象分配了多少内存(或实例的数量)，并根据它们的使用历史删除最旧的内存以保存最近的内存。Here+is是一个关于如何使用它的很好的教程。|179153|在我的例子中，我创建了两个缓存实例:用于拇指和附件。通过单例访问使它们成为静态的，因此它们在整个应用程序中都是可用的。|179154|缓存类：|179155|public+class+BitmapLruCache+extends+LruCache<Uri,+byte[]>+{

++++private+static+final+float+CACHE_PART_FOR_THUMBS_PRC+=+0.01f;+//+1%25+(Nexus+5X+-+5Mb)
++++private+static+final+float+CACHE_PART_FOR_ATTACHMENTS_PRC+=+0.03f;//+3%25+(Nexus+5X+-+16Mb)
++++private+static+BitmapLruCache+thumbCacheInstance;
++++private+static+BitmapLruCache+attachmentCacheInstance;

public+static+synchronized+BitmapLruCache+getDecryptedThumbCacheInstance()+{
++++if+(thumbCacheInstance+==+null)+{

++++++++int+cacheSize+=+getCacheSize(CACHE_PART_FOR_THUMBS_PRC);
++++//L.log("creating+BitmapLruCache+for+Thumb+with+size:+"+%2B+cacheSize+%2B+"+bytes");
++++++++thumbCacheInstance+=+new+BitmapLruCache(cacheSize);
++++++++return+thumbCacheInstance;
++++}+else+{
++++++++return+thumbCacheInstance;
++++}
}

public+static+synchronized+BitmapLruCache+getDecryptedAttachmentCacheInstance()+{
++++if+(attachmentCacheInstance+==+null)+{

++++++++int+cacheSize+=+getCacheSize(CACHE_PART_FOR_ATTACHMENTS_PRC);
++++//++++++++++++L.log("creating+BitmapLruCache+for+Attachment+with+size:+"+%2B+cacheSize+%2B+"+bytes");
++++++++attachmentCacheInstance+=+new+BitmapLruCache(cacheSize);
++++++++return+attachmentCacheInstance;
++++}+else+{
++++++++return+attachmentCacheInstance;
++++}
}

private+BitmapLruCache(int+maxSize)+{
++++super(maxSize);
}

public+void+addBitmap(Uri+uri,+byte[]+bitmapBytes)+{
++++if+(get(uri)+==+null+&&+bitmapBytes+!=+null)
++++++++put(uri,+bitmapBytes);
}

public+byte[]+getBitmap(Uri+uri)+{
++++return+get(uri);
}


@Override
protected+int+sizeOf(Uri+uri,+byte[]+bitmapBytes)+{
++++//+The+cache+size+will+be+measured+in+bytes+rather+than+number+of+items.
++++return+bitmapBytes.length;
}
}|code-block|syntax|javascript|179156|这是我计算可用空闲RAM的方法，以及我可以从中获得多少内存：|179157|private+static+int+getCacheSize(float+partOfTotalFreeMemoryToUseAsCache){
++++final+long+maxMemory+=+Runtime.getRuntime().maxMemory();
++++//Use+...+of+available+memory+for+List+Notes+thumb+cache
++++return+(int)+(maxMemory+*+partOfTotalFreeMemoryToUseAsCache);
}|179158|下面是我在Adapters中使用它来获取缓存图像的方法：|179159|byte[]+decryptedThumbnail+=+BitmapLruCache.getDecryptedThumbCacheInstance().getBitmap(thumbUri);|179160|以及如何将其设置到后台线程的缓存中(常规AsyncTask)：|179161|BitmapLruCache.getDecryptedThumbCacheInstance().addBitmap(thumbUri,+thumbBytes);+|179162|我的应用程序以API+19%2B为目标，所以设备并不旧，在我的例子中，这些可用内存的部分足够缓存(1%25和3%25)。|179163|有趣的事实：安卓没有任何API或其他黑客来获取分配给你的应用程序的内存量，它是根据各种因素动态计算的。|style|BOLD|179164|179165|附注:我使用静态类字段来保存缓存，但根据最新的安卓指南，建议使用ViewModel+architecture+component。|179166|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.android.com/studio/profile/memory-profiler|1|IMAGE|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/69755039c73efc6e1eb98f5fe66ea3ac.png|imageAlt|2|https://stuff.mit.edu/afs/sipb/project/android/docs/reference/android/util/LruCache.html|3|https://stuff.mit.edu/afs/sipb/project/android/docs/training/displaying-bitmaps/cache-bitmap.html|4|https://developer.android.com/topic/libraries/architecture/viewmodel^0|0|0|9|N|0|0|0|0|0|1|1|0|0|0|0|0|0|0|L|E|2|2O|7|3|0|0|0|0|0|0|0|0|0|0|0|0|6|0|0|W|W|4|0^^$0|@$1|2|3|4|5|6|7|2E|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|2F|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|2G|8|@]|9|@$F|2H|G|2I|1|2J]]|A|$]]|$1|H|3|I|5|6|7|2K|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|2L|8|@]|9|@]|A|$]]|$1|L|3|M|5|N|7|2M|8|@]|9|@$F|2N|G|2O|1|2P]]|A|$]]|$1|O|3|K|5|6|7|2Q|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|2R|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|2S|8|@]|9|@]|A|$]]|$1|T|3|U|5|6|7|2T|8|@]|9|@]|A|$]]|$1|V|3|-4|5|6|7|2U|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|2V|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|2W|8|@]|9|@$F|2X|G|2Y|1|2Z]|$F|30|G|31|1|32]]|A|$]]|$1|10|3|11|5|6|7|33|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|34|8|@]|9|@]|A|$]]|$1|14|3|15|5|16|7|35|8|@]|9|@]|A|$17|18]]|$1|19|3|1A|5|6|7|36|8|@]|9|@]|A|$]]|$1|1B|3|1C|5|16|7|37|8|@]|9|@]|A|$17|18]]|$1|1D|3|1E|5|6|7|38|8|@]|9|@]|A|$]]|$1|1F|3|1G|5|16|7|39|8|@]|9|@]|A|$17|18]]|$1|1H|3|1I|5|6|7|3A|8|@]|9|@]|A|$]]|$1|1J|3|1K|5|16|7|3B|8|@]|9|@]|A|$17|18]]|$1|1L|3|1M|5|6|7|3C|8|@]|9|@]|A|$]]|$1|1N|3|1O|5|6|7|3D|8|@$F|3E|G|3F|1P|1Q]]|9|@]|A|$]]|$1|1R|3|-4|5|6|7|3G|8|@]|9|@]|A|$]]|$1|1S|3|1T|5|6|7|3H|8|@]|9|@$F|3I|G|3J|1|3K]]|A|$]]|$1|1U|3|-4|5|6|7|3L|8|@]|9|@]|A|$]]]|1V|$1W|$5|1X|1Y|1Z|A|$20|21]]|22|$5|23|1Y|24|A|$25|26|27|-4]]|28|$5|1X|1Y|1Z|A|$20|29]]|2A|$5|1X|1Y|1Z|A|$20|2B]]|2C|$5|1X|1Y|1Z|A|$20|2D]]]]

It's the end of 2018 so things have changed.

First of all: run your app and open Android Profiler tab in Android Studio.
You will see how much memory it consumes, you will be surprised but it can allocate a lot of RAM.

Also <a href="https://developer.android.com/studio/profile/memory-profiler" rel="noreferrer">here is a great article</a> in official docs with detailed instructions on how to use Memory Profiler which can give you an in-depth look of your memory management. 

But in most of the cases, your regular Android Profiler will be enough for you.

<a href="https://i.stack.imgur.com/YajxF.png" rel="noreferrer"><img src="https://i.stack.imgur.com/YajxF.png" alt="enter image description here"></a>

Usually, an app starts with 50Mb of RAM allocation but instantly jumps up to 90Mb when you start loading some photos in memory. When you open Activity with a ViewPager with preloaded photos (3,5Mb each) you can get 190Mb easily in seconds.

But this doesn't mean you have issues with memory management. 

The best advice I can give is to follow the guidelines and best practices, use top libraries for image loading (Glide, Picasso) and you'll be OK.

<hr>

But if you need to tailor something and you really need to know how much memory you can allocate manually you can get total free memory and calculate a pre-determined portion (in %) out of it. 
In my case, I needed to cache decrypted photos in memory so I don't need to decrypt them everytime user slides through the list.

For this purpose you can use ready to use <a href="https://stuff.mit.edu/afs/sipb/project/android/docs/reference/android/util/LruCache.html" rel="noreferrer">LruCache class</a>. It's a cache class which automatically tracks of how much memory your objects allocate (or the number of instances) and removes the oldest to keep the recent by their usage history.
<a href="https://stuff.mit.edu/afs/sipb/project/android/docs/training/displaying-bitmaps/cache-bitmap.html" rel="noreferrer">Here is</a> a great tutorial on how to use it.

In my case, I created 2 instances of caches: for thumbs and attachments.
Made them static with singleton access so they are available globally throughout the app.

cache class:

<pre><code>public class BitmapLruCache extends LruCache&lt;Uri, byte[]&gt; {

 private static final float CACHE_PART_FOR_THUMBS_PRC = 0.01f; // 1% (Nexus 5X - 5Mb)
 private static final float CACHE_PART_FOR_ATTACHMENTS_PRC = 0.03f;// 3% (Nexus 5X - 16Mb)
 private static BitmapLruCache thumbCacheInstance;
 private static BitmapLruCache attachmentCacheInstance;

public static synchronized BitmapLruCache getDecryptedThumbCacheInstance() {
 if (thumbCacheInstance == null) {

 int cacheSize = getCacheSize(CACHE_PART_FOR_THUMBS_PRC);
 //L.log("creating BitmapLruCache for Thumb with size: " + cacheSize + " bytes");
 thumbCacheInstance = new BitmapLruCache(cacheSize);
 return thumbCacheInstance;
 } else {
 return thumbCacheInstance;
 }
}

public static synchronized BitmapLruCache getDecryptedAttachmentCacheInstance() {
 if (attachmentCacheInstance == null) {

 int cacheSize = getCacheSize(CACHE_PART_FOR_ATTACHMENTS_PRC);
 // L.log("creating BitmapLruCache for Attachment with size: " + cacheSize + " bytes");
 attachmentCacheInstance = new BitmapLruCache(cacheSize);
 return attachmentCacheInstance;
 } else {
 return attachmentCacheInstance;
 }
}

private BitmapLruCache(int maxSize) {
 super(maxSize);
}

public void addBitmap(Uri uri, byte[] bitmapBytes) {
 if (get(uri) == null &amp;&amp; bitmapBytes != null)
 put(uri, bitmapBytes);
}

public byte[] getBitmap(Uri uri) {
 return get(uri);
}


@Override
protected int sizeOf(Uri uri, byte[] bitmapBytes) {
 // The cache size will be measured in bytes rather than number of items.
 return bitmapBytes.length;
}
}
</code></pre>

This is how I calculate available free RAM and how much I can bite out of it:

<pre><code>private static int getCacheSize(float partOfTotalFreeMemoryToUseAsCache){
 final long maxMemory = Runtime.getRuntime().maxMemory();
 //Use ... of available memory for List Notes thumb cache
 return (int) (maxMemory * partOfTotalFreeMemoryToUseAsCache);
}
</code></pre>

And this is how I use it in Adapters to get cached image:

<pre><code>byte[] decryptedThumbnail = BitmapLruCache.getDecryptedThumbCacheInstance().getBitmap(thumbUri);
</code></pre>

and how I set it into cache in background thread (regular AsyncTask):

<pre><code>BitmapLruCache.getDecryptedThumbCacheInstance().addBitmap(thumbUri, thumbBytes); 
</code></pre>

My app targets API 19+ so devices are not old and these portions of available RAM are good enough for cache in my case (1% and 3%).

Fun fact: Android does not have any APIs or other hacks to get the amount of memory allocated to your app, it's calculated on the fly based on various factors.

<hr>

P.S. I'm using a static class field to hold a cache but as per the latest Android guidelines its recommended to use <a href="https://developer.android.com/topic/libraries/architecture/viewmodel" rel="noreferrer">ViewModel architecture component</a> for that purpose.

blocks|key|2784547|text|不再有任何限制。为什么会有呢？请记住，Android历史上来自嵌入式设备世界，在嵌入式设备世界中，每个应用程序都有明确的简单任务要做，通常根本不允许动态内存使用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2784548|它不被认为是一个通用的系统。我们仍然可以看到这个古老时代的许多设计文物，它们在“真正的电脑”上从来没有意义，这也是为什么iOS有比安卓更好的应用程序的原因，它被设计得更好，更容易为用户驱动的任务编程。|2784549|在应用程序设计中，重要的是你的活动对"onLowMemory“信号有很好的反应。|2784550|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

There isn't any limit anymore. Why should there? Remember that Android was historically coming from the the embedded devices world where every app had clear simple tasks to do, often disallowing dynamical memory usage at all.
It was not considered a general purpose system. We can still see a lot of design artifacts of this ancient times that never made sense on a &quot;real computer&quot; and is a reason why iOS has so many better apps then android, it was designed much better and easier to program for user driven task.
Important in app design is that your activity reacts well to &quot;onLowMemory&quot; signals.

blocks|key|2784561|text|现在，我正在开发一个应用程序和我正在使用的三星Ultra+S21+(甚至还有16+of的内存)。不允许我使用超过500MB的此应用程序，即使清单中的android:largeHeap=为“true”。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2784562|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Right now, I am working on an App and the Samsung Ultra S21 that I am using (even having 16GB of ram available..) does not allow me to use more than 500MB for this App even with android:largeHeap=&quot;true&quot; in the Manifest.

I am quite curious about this question concerning the memory management of the Android operating system so I hope for a quite detailed answer on that topic.

What I would like to know:

<ul>
<li>What is the maximum amount of memory (in megabytes / as
percentage of the total RAM) that an Android application (that is not a system app) can use?</li>
<li>Are there any differences between Android versions?</li>
<li>Are there any differences concerning the manufacturer of the device?</li>
</ul>

And most importantly:

<ul>
<li>What is considered / what does it depend on when it comes to the system determining how much RAM an app can use at runtime (assuming that the memory maximum per app is not a static number)?</li>
</ul>

What I have heard so far (up until 2013):

<ul>
<li>Early Android devices had a per-app cap of 16MB</li>
<li>Later this cap increased to 24MB or 32MB</li>
</ul>

What makes me very curious:

Both of these limits are very low.

I have just recently downloaded the <a href="https://play.google.com/store/apps/details?id=com.james.SmartTaskManager&amp;hl=de" rel="noreferrer">Android Task Manager</a> to check my devices RAM. What I have noticed is that there are applications using around 40-50 megabytes of RAM, which is obvioulsy more than the mentioned maximum RAM usage of let's say 32 MB. So how does Android determine how much RAM an app can use? How is it possible that apps exceed that limit?

Furthermore, I noticed that some apps of mine crash (killed by the system?) with an OutOfMemoryException when using around 30-40 Megabytes. On the other hand, I have apps running on my phone using 100 MB and more after some time (probably due to memory leaks) that do not crash or get killed off.
So it obviously also depends on the app itself when it comes to determining how much RAM can be spared. How is this possible?
(I conducted my tests with an HTC One S with 768 MB RAM)

Disclaimer: I am NOT affiliated with Android Task Manager app in any way.

What is the maximum amount of RAM an app can use?

Android Studio

内存管理

虚拟机

Android

我对这个关于安卓操作系统的内存管理的问题很好奇，所以我希望在这个问题上有一个相当详细的答案。我想知道的是：安卓应用程序(即非系统应用程序)可以使用的最大内存量(以 an为单位)是多少？安卓versionsAre设备的manufacturer有什么不同？最重要的是：考虑What /当涉及到系统确定应用程序在运行时可以使用...

问一个应用程序可以使用的最大RAM是多少？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问一个应用程序可以使用的最大RAM是多少？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问一个应用程序可以使用的最大RAM是多少？
EN