blocks|key|2800571|text|要测量当前内存的使用情况，请使用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2800572|Runtime.getRuntime().freeMemory()，Runtime.getRuntime().totalMemory()|offset|length|style|CODE|2800573|下面是一个很好的例子：获取操作系统级系统信息|2800574|但是这个测量不精确，但是它可以给你很多信息。另一个问题是GC，这是不可预测的。|2800575|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/25552/using-java-to-get-os-level-system-information^0|0|0|X|Y|Y|0|B|B|0|0|S|2|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@$D|V|E|W|F|G]|$D|X|E|Y|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|Z|8|@]|9|@$D|10|E|11|1|12]]|A|$]]|$1|J|3|K|5|6|7|13|8|@$D|14|E|15|F|G]]|9|@]|A|$]]|$1|L|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|M|$N|$5|O|P|Q|A|$R|S]]]]

To measure current memory usage use :

<code>Runtime.getRuntime().freeMemory()</code> ,
<code>Runtime.getRuntime().totalMemory()</code>

Here is a good example:
<a href="https://stackoverflow.com/questions/25552/using-java-to-get-os-level-system-information">get OS-level system information</a>

But this measurement is not precise but it can give you much information.
Another problem is with <code>GC</code> which is unpredictable.

blocks|key|2800646|text|下面是Netty的一个例子，它做了一些类似的事情：MemoryAwareThreadPoolExecutor。番石榴的缓存类也有一个基于大小的驱逐。您可以查看这些源，并复制它们正在做的事情。具体来说，这里是Netty是如何估计对象大小的。本质上，您将估计方法中生成的对象的大小，并对其进行计数。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2800647|获取总体内存信息(比如堆可用/使用的数量)将帮助您决定分配给该方法的内存使用量，而不是跟踪单个方法调用使用了多少内存。|2800648|话虽如此，但你很难合法地需要这个。在大多数情况下，通过限制给定点上的对象数量(例如，使用有界队列)来限制内存使用是足够好的，而且实现起来要简单得多。|2800649|entityMap|0|LINK|mutability|MUTABLE|url|http://grepcode.com/file/repo1.maven.org/maven2/org.jboss.netty/netty/3.0.0.CR1/org/jboss/netty/handler/execution/MemoryAwareThreadPoolExecutor.java|1|https://code.google.com/p/guava-libraries/wiki/CachesExplained|2|http://grepcode.com/file/repo1.maven.org/maven2/com.ning/metrics.goodwill-access/0.0.10/org/jboss/netty/util/DefaultObjectSizeEstimator.java?av=h#DefaultObjectSizeEstimator^0|P|T|0|1N|3|1|33|6|2|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@$A|U|B|V|1|W]|$A|X|B|Y|1|Z]|$A|10|B|11|1|12]]|C|$]]|$1|D|3|E|5|6|7|13|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|14|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|15|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]|P|$5|K|L|M|C|$N|Q]]|R|$5|K|L|M|C|$N|S]]]]

Here is an example from Netty which does something similar: <a href="http://grepcode.com/file/repo1.maven.org/maven2/org.jboss.netty/netty/3.0.0.CR1/org/jboss/netty/handler/execution/MemoryAwareThreadPoolExecutor.java" rel="nofollow">MemoryAwareThreadPoolExecutor</a>. Guava's <a href="https://code.google.com/p/guava-libraries/wiki/CachesExplained" rel="nofollow">cache class</a> has also a size based eviction. You could look at these sources and copy what they are doing. In particular, Here is how Netty is <a href="http://grepcode.com/file/repo1.maven.org/maven2/com.ning/metrics.goodwill-access/0.0.10/org/jboss/netty/util/DefaultObjectSizeEstimator.java?av=h#DefaultObjectSizeEstimator" rel="nofollow">estimating object sizes</a>. In essence, you'd estimate the size of the objects you generate in the method and keep a count.

Getting overall memory information (like how much heap is available/used) will help you decide how much memory usage to allocate to the method, but not to track how much memory was used by the individual method calls.

Having said that, it's very rare that you legitimately need this. In most cases, capping the memory usage by limiting how many objects can be there at a given point (e.g. by using a bounded queue) is good enough and is much, much simpler to implement.

blocks|key|440257|text|我可以想到几种选择：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|440258|通过微基准(即jmh)来找出您的方法需要多少内存。|unordered-list-item|offset|length|440259|基于启发式估计的建筑物分配策略。有几种实现类大小估计的开源解决方案，即ClassSize。一种更容易的方法是使用缓存来释放很少使用的对象(即番石榴的缓存)。正如@EnnoShioji所提到的，番石榴的缓存具有基于内存的驱逐策略。|440260|您还可以编写自己的基准测试，以计数内存。我的想法是|440261|只有一个线程在运行。|ordered-list-item|440262|创建一个新数组来存储要分配的对象。因此，在GC运行期间不会收集这些对象。|440263|System.gc()，memoryBefore+=+runtime.totalMemory()+-+runtime.freeMemory()|style|CODE|440264|分配你的对象。把它们放进阵列里。|440265|System.gc()，memoryAfter+=+runtime.totalMemory()+-+runtime.freeMemory()|440266|这是我在我的轻量级微基准工具中使用的一种技术，它能够以字节精度测量内存分配。|440267|entityMap|0|LINK|mutability|MUTABLE|url|http://openjdk.java.net/projects/code-tools/jmh/|1|http://svn.apache.org/repos/asf/hbase/branches/0.89-fb/src/main/java/org/apache/hadoop/hbase/util/ClassSize.java|2|https://github.com/chaschev/experiments-with-microbes/blob/master/src/test/java/com/chaschev/microbe/samples/MemConsumptionTest.java^0|0|7|3|0|0|Z|9|1|0|0|0|0|0|B|C|1N|0|0|0|B|C|1M|0|6|8|2|0^^$0|@$1|2|3|4|5|6|7|1B|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1C|8|@]|9|@$E|1D|F|1E|1|1F]]|A|$]]|$1|G|3|H|5|D|7|1G|8|@]|9|@$E|1H|F|1I|1|1J]]|A|$]]|$1|I|3|J|5|6|7|1K|8|@]|9|@]|A|$]]|$1|K|3|L|5|M|7|1L|8|@]|9|@]|A|$]]|$1|N|3|O|5|M|7|1M|8|@]|9|@]|A|$]]|$1|P|3|Q|5|M|7|1N|8|@$E|1O|F|1P|R|S]|$E|1Q|F|1R|R|S]]|9|@]|A|$]]|$1|T|3|U|5|M|7|1S|8|@]|9|@]|A|$]]|$1|V|3|W|5|M|7|1T|8|@$E|1U|F|1V|R|S]|$E|1W|F|1X|R|S]]|9|@]|A|$]]|$1|X|3|Y|5|6|7|1Y|8|@]|9|@$E|1Z|F|20|1|21]]|A|$]]|$1|Z|3|-4|5|6|7|22|8|@]|9|@]|A|$]]]|10|$11|$5|12|13|14|A|$15|16]]|17|$5|12|13|14|A|$15|18]]|19|$5|12|13|14|A|$15|1A]]]]

I can think of several options:

<ul>
<li>Finding out how much memory your method requires via a microbenchmark (i.e. <a href="http://openjdk.java.net/projects/code-tools/jmh/" rel="noreferrer">jmh</a>). </li>
<li>Building allocation strategies based on heuristic estimation. There are several open source solutions implementing class size estimation i.e. <a href="http://svn.apache.org/repos/asf/hbase/branches/0.89-fb/src/main/java/org/apache/hadoop/hbase/util/ClassSize.java" rel="noreferrer">ClassSize</a>. A much easier way could be utilizing a cache which frees rarely used objects (i.e. Guava's Cache). As mentioned by @EnnoShioji, Guava's cache has memory-based eviction policies.</li>
</ul>

You can also write your own benchmark test which counts memory. The idea is to

<ol>
<li>Have a single thread running.</li>
<li>Create a new array to store your objects to allocate. So these objects won't be collected during GC run.</li>
<li><code>System.gc()</code>, <code>memoryBefore = runtime.totalMemory() - runtime.freeMemory()</code></li>
<li>Allocate your objects. Put them into the array.</li>
<li><code>System.gc()</code>, <code>memoryAfter = runtime.totalMemory() - runtime.freeMemory()</code></li>
</ol>

This is a technique I used in my <a href="https://github.com/chaschev/experiments-with-microbes/blob/master/src/test/java/com/chaschev/microbe/samples/MemConsumptionTest.java" rel="noreferrer">lightweight micro-benchmark tool</a> which is capable of measuring memory allocation with byte-precision.

blocks|key|2800706|text|您可以使用分析器(用于前。JProfiler)，用于按类查看内存使用情况。或者，如何提到Areo，只需打印内存使用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2800707|++++Runtime+runtime+=+Runtime.getRuntime();
++++long+usedMemoryBefore+=+runtime.totalMemory()+-+runtime.freeMemory();
++++System.out.println("Used+Memory+before"+%2B+usedMemoryBefore);
++++++++//+working+code+here
++++long+usedMemoryAfter+=+runtime.totalMemory()+-+runtime.freeMemory();
++++System.out.println("Memory+increased:"+%2B+(usedMemoryAfter-usedMemoryBefore));|code-block|syntax|javascript|2800708|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can use profiler (for ex. JProfiler) for view memory usage by classes. Or , how mentioned Areo, just print memory usage:

<pre><code> Runtime runtime = Runtime.getRuntime();
 long usedMemoryBefore = runtime.totalMemory() - runtime.freeMemory();
 System.out.println("Used Memory before" + usedMemoryBefore);
 // working code here
 long usedMemoryAfter = runtime.totalMemory() - runtime.freeMemory();
 System.out.println("Memory increased:" + (usedMemoryAfter-usedMemoryBefore));
</code></pre>

blocks|key|438852|text|这个问题有点棘手，因为Java可以在处理过程中分配大量短暂的对象，这些对象随后将在垃圾收集期间被收集。在公认的答案中，我们不能肯定地说垃圾收集已经在任何给定的时间运行。即使我们引入一个循环结构，使用多个System.gc()调用，垃圾收集也可能在我们的方法调用之间运行。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|438853|一个更好的方法是使用https://cruftex.net/2017/03/28/The-6-Memory-Metrics-You-Should-Track-in-Your-Java-Benchmarks.html中建议的一些变化，在这里触发System.gc()，但我们也等待报告的GC计数增加：|438854|long+getGcCount()+{
++++long+sum+=+0;
++++for+(GarbageCollectorMXBean+b+:+ManagementFactory.getGarbageCollectorMXBeans())+{
++++++++long+count+=+b.getCollectionCount();
++++++++if+(count+!=+-1)+{+sum+%2B=+count;+}
++++}
++++return+sum;
}

long+getReallyUsedMemory()+{
++++long+before+=+getGcCount();
++++System.gc();
++++while+(getGcCount()+==+before);
++++return+getCurrentlyAllocatedMemory();
}

long+getCurrentlyAllocatedMemory()+{
++++final+Runtime+runtime+=+Runtime.getRuntime();
++++return+(runtime.totalMemory()+-+runtime.freeMemory())+/+(1024+*+1024);
}|code-block|syntax|javascript|438855|这仍然只给出了代码在给定时间实际分配的内存的近似值，但是这个值通常更接近人们通常感兴趣的内容。|438856|entityMap|0|LINK|mutability|MUTABLE|url|https://cruftex.net/2017/03/28/The-6-Memory-Metrics-You-Should-Track-in-Your-Java-Benchmarks.html^0|2T|B|0|3D|B|A|2P|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@$9|10|A|11|B|C]]|D|@$9|12|A|13|1|14]]|E|$]]|$1|H|3|I|5|J|7|15|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|16|8|@]|D|@]|E|$]]|$1|O|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]]]

This question is a bit tricky, due to the way in which Java can allocate a lot of short-lived objects during processing, which will subsequently be collected during garbage collection. In the accepted answer, we cannot say with any certainty that garbage collection has been run at any given time. Even if we introduce a loop structure, with multiple <code>System.gc()</code> calls, garbage collection might run in between our method calls.

A better way is to instead use some variation of what is suggested in <a href="https://cruftex.net/2017/03/28/The-6-Memory-Metrics-You-Should-Track-in-Your-Java-Benchmarks.html" rel="nofollow noreferrer">https://cruftex.net/2017/03/28/The-6-Memory-Metrics-You-Should-Track-in-Your-Java-Benchmarks.html</a>, where <code>System.gc()</code> is triggered but we also wait for the reported GC count to increase:

<pre><code>long getGcCount() {
 long sum = 0;
 for (GarbageCollectorMXBean b : ManagementFactory.getGarbageCollectorMXBeans()) {
 long count = b.getCollectionCount();
 if (count != -1) { sum += count; }
 }
 return sum;
}

long getReallyUsedMemory() {
 long before = getGcCount();
 System.gc();
 while (getGcCount() == before);
 return getCurrentlyAllocatedMemory();
}

long getCurrentlyAllocatedMemory() {
 final Runtime runtime = Runtime.getRuntime();
 return (runtime.totalMemory() - runtime.freeMemory()) / (1024 * 1024);
}
</code></pre>

This still gives only an approximation of the memory actually allocated by your code at a given time, but the value is typically much closer to what one would usually be interested in.

blocks|key|438863|text|下面是一个在单独线程中运行内存使用情况的示例代码。由于GC可以在进程运行时随时触发，这将每秒钟记录一次内存使用情况，并报告所使用的最大内存。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|438864|runnable是需要测量的实际流程，而runTimeSecs是进程运行的预期时间。这是为了确保线程计算内存不会在实际进程之前终止。|offset|length|style|CODE|438865|public+void+recordMemoryUsage(Runnable+runnable,+int+runTimeSecs)+{
++++try+{
++++++++CompletableFuture<Void>+mainProcessFuture+=+CompletableFuture.runAsync(runnable);
++++++++CompletableFuture<Void>+memUsageFuture+=+CompletableFuture.runAsync(()+->+{


++++++++++++long+mem+=+0;
++++++++++++for+(int+cnt+=+0;+cnt+<+runTimeSecs;+cnt%2B%2B)+{
++++++++++++++++long+memUsed+=+Runtime.getRuntime().totalMemory()+-+Runtime.getRuntime().freeMemory();
++++++++++++++++mem+=+memUsed+>+mem+?+memUsed+:+mem;
++++++++++++++++try+{
++++++++++++++++++++TimeUnit.SECONDS.sleep(1);
++++++++++++++++}+catch+(InterruptedException+e)+{
++++++++++++++++++++e.printStackTrace();
++++++++++++++++}
++++++++++++}
++++++++++++;
++++++++++++System.out.println("Max+memory+used+(gb):+"+%2B+mem/1000000000D);
++++++++});

++++++++CompletableFuture<Void>+allOf+=+CompletableFuture.allOf(mainProcessFuture,+memUsageFuture);
++++++++allOf.get();
++++}+catch+(Exception+e)+{
++++++++e.printStackTrace();
++++}
}|code-block|syntax|javascript|438866|entityMap^0|0|0|8|K|B|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@$D|Q|E|R|F|G]|$D|S|E|T|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|U|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|N|$]]

Here is a sample code to run memory usage in a separate thread. Since the GC can be triggered anytime when the process is running, this will record memory usage every second and report out the maximum memory used.

The <code>runnable</code> is the actual process that needs measuring, and <code>runTimeSecs</code> is the expected time the process will run. This is to ensure the thread calculating memory does not terminate before the actual process.

<pre><code>public void recordMemoryUsage(Runnable runnable, int runTimeSecs) {
 try {
 CompletableFuture&lt;Void&gt; mainProcessFuture = CompletableFuture.runAsync(runnable);
 CompletableFuture&lt;Void&gt; memUsageFuture = CompletableFuture.runAsync(() -&gt; {


 long mem = 0;
 for (int cnt = 0; cnt &lt; runTimeSecs; cnt++) {
 long memUsed = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
 mem = memUsed &gt; mem ? memUsed : mem;
 try {
 TimeUnit.SECONDS.sleep(1);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
 ;
 System.out.println("Max memory used (gb): " + mem/1000000000D);
 });

 CompletableFuture&lt;Void&gt; allOf = CompletableFuture.allOf(mainProcessFuture, memUsageFuture);
 allOf.get();
 } catch (Exception e) {
 e.printStackTrace();
 }
}
</code></pre>

blocks|key|440319|text|估计内存使用量的最简单方法是使用来自Runtime类的方法。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|440320|我建议不要依赖它，而是只用于近似估计。理想情况下，您应该只记录这些信息并自行分析，而不将其用于测试或代码的自动化。|BOLD|440321|也许它不是很可靠，但是在像单元测试这样的封闭环境中，它可能会给出接近现实的估计值。|440322|特别是在调用System.gc()垃圾收集器之后，我们不能保证它会在我们期望的时候运行(这只是对GC的一个建议)，在这里描述的freeMemory方法存在精度限制：https://stackoverflow.com/a/17376879/1673775，可能会有更多的警告。|440323|解决方案：|440324|private+static+final+long+BYTE_TO_MB_CONVERSION_VALUE+=+1024+*+1024;

@Test
public+void+memoryUsageTest()+{
++long+memoryUsageBeforeLoadingData+=+getCurrentlyUsedMemory();
++log.debug("Used+memory+before+loading+some+data:+"+%2B+memoryUsageBeforeLoadingData+%2B+"+MB");
++List<SomeObject>+somethingBigLoadedFromDatabase+=+loadSomethingBigFromDatabase();
++long+memoryUsageAfterLoadingData+=+getCurrentlyUsedMemory();
++log.debug("Used+memory+after+loading+some+data:+"+%2B+memoryUsageAfterLoadingData+%2B+"+MB");
++log.debug("Difference:+"+%2B+(memoryUsageAfterLoadingData+-+memoryUsageBeforeLoadingData)+%2B+"+MB");
++someOperations(somethingBigLoadedFromDatabase);
}

private+long+getCurrentlyUsedMemory()+{
++System.gc();
++return+(Runtime.getRuntime().totalMemory()+-+Runtime.getRuntime().freeMemory())+/+BYTE_TO_MB_CONVERSION_VALUE;
}|code-block|syntax|javascript|440325|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/17376879/1673775^0|I|7|0|0|1L|0|0|15|0|0|3T|6|B|1R|A|2A|18|0|0|0|5|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@$9|12|A|13|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|14|8|@$9|15|A|16|B|H]]|D|@]|E|$]]|$1|I|3|J|5|6|7|17|8|@$9|18|A|19|B|H]]|D|@]|E|$]]|$1|K|3|L|5|6|7|1A|8|@$9|1B|A|1C|B|H]|$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]]|D|@$9|1H|A|1I|1|1J]]|E|$]]|$1|M|3|N|5|6|7|1K|8|@$9|1L|A|1M|B|H]]|D|@]|E|$]]|$1|O|3|P|5|Q|7|1N|8|@]|D|@]|E|$R|S]]|$1|T|3|-4|5|6|7|1O|8|@]|D|@]|E|$]]]|U|$V|$5|W|X|Y|E|$Z|10]]]]

<h2>The easiest way to estimate memory usage is to use methods from <code>Runtime</code> class.</h2>
I suggest not to rely on it, but use it only for approximate estimations. Ideally you should only log this information and analyze it on your own, without using it for automation of your test or code.
Probably it isn't very reliable, but in closed environment like unit test it may give you estimate close to reality. 
Especially there is no guarantee that after calling <code>System.gc()</code> garbage collector will run when we expect it (it is only a suggestion for GC), there are precision limitations of the <code>freeMemory</code> method described there: <a href="https://stackoverflow.com/a/17376879/1673775">https://stackoverflow.com/a/17376879/1673775</a> and there might be more caveats.
<h3>Solution:</h3>
<pre><code>private static final long BYTE_TO_MB_CONVERSION_VALUE = 1024 * 1024;

@Test
public void memoryUsageTest() {
 long memoryUsageBeforeLoadingData = getCurrentlyUsedMemory();
 log.debug(&quot;Used memory before loading some data: &quot; + memoryUsageBeforeLoadingData + &quot; MB&quot;);
 List&lt;SomeObject&gt; somethingBigLoadedFromDatabase = loadSomethingBigFromDatabase();
 long memoryUsageAfterLoadingData = getCurrentlyUsedMemory();
 log.debug(&quot;Used memory after loading some data: &quot; + memoryUsageAfterLoadingData + &quot; MB&quot;);
 log.debug(&quot;Difference: &quot; + (memoryUsageAfterLoadingData - memoryUsageBeforeLoadingData) + &quot; MB&quot;);
 someOperations(somethingBigLoadedFromDatabase);
}

private long getCurrentlyUsedMemory() {
 System.gc();
 return (Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory()) / BYTE_TO_MB_CONVERSION_VALUE;
}
</code></pre>

Assuming I have a class that does some heavy processing, operating with several collections. What I want to do is to make sure that such operation can't lead to out-of-memory or even better I want to set a threshold of how much memory it can use.

<pre><code>class MyClass()
{
 public void myMethod()
 {
 for(int i=0; i&lt;10000000; i++)
 {
 // Allocate some memory, may be several collections
 }
 }
}

class MyClassTest
{
 @Test
 public void myMethod_makeSureMemoryFootprintIsNotBiggerThanMax()
 {
 new MyClass().myMethod(); 
 // How do I measure amount of memory it may try to allocate?
 }
}
</code></pre>

What is the right approach to do this? Or this is not possible/not feasible?

Java unit testing: how to measure memory footprint for method call

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

假设我有一个类，它执行一些繁重的处理，操作几个集合。我想要做的是确保这样的操作不会导致内存不足，或者更好的是，我希望设置一个阈值，说明它可以使用多少内存。class MyClass(){ public void myMethod() { for(int i=0; i<10000000; i++) ...

问Java单元测试:如何度量方法调用的内存占用
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java单元测试:如何度量方法调用的内存占用EN