标签: heap-memory

正如 CLR via C# 中所述，“当 CLR 初始化时，它会为每一代选择一个预算大小。”。假设 Gen0 为 256KB，Gen1 为 2MB，Gen2 为 10MB。（不确定这是否包括大对象堆）

当然，随着更多对象的创建和堆大小的增加，这个预算也必须增加。

我知道 GC.GetTotalMemory() 方法返回已消耗的总内存，但它没有提供有关每代消耗的信息。

有没有办法获得分配给每一代的堆大小？

到目前为止，我在使用 Linux 时，堆栈地址非常高，而堆地址非常低（通过使用 C 程序打印堆和堆栈地址可以看出），我对 Win32 进程内存布局有一个问题。MWSDN说堆栈地址高于堆地址，但从我在实践中看到的情况来看，堆栈地址低于堆地址。所以我很困惑。有人请解释一下。

所以，如果我想声明一个字符数组，我可以这样做

char a[2];
char * a ;
char * a = new char[2];

忽略第一个声明，其他两个使用指针。据我所知，第三个声明存储在堆中，并使用删除运算符释放。第二个声明是否也将数组保存在堆中？这是否意味着如果某些内容存储在堆中并且未释放，则可以在文件中的任何位置使用，例如具有文件链接的变量？我在一个函数中尝试了第三个和第二个声明，然后在另一个函数中使用该变量，但它不起作用，为什么？第二个和第三个声明之间还有其他区别吗？

我正在学习一些具有 C++ 背景的 Java 课程和对象课程。我想知道为什么我们不能选择在堆栈内存上声明的对象？为什么除了原始类型之外的所有内容都必须放在堆上？

这是澄清我所问内容的一些内容。

本质上，如果我们有：

Scanner input = new Scanner(System.in);

那么为什么我们不能首先将它放在堆栈上呢？

我正在编写一个程序来计算两个数字的最大公约数，但我遇到了malloc函数和指针的问题。实际上，堆栈和堆段在内存中如何工作以及为什么工作是很清楚的。但是，我还无法理解malloc在程序中何时声明指针和使用是否有效、是否必要。这是代码：

#include <iostream>
#include <stdlib.h>
#include <stdio.h>

int *calcolaDivisori(int);

int main(int argc, char** argv) {

    int foundCounter = 0;
    int i,j,s1,s2;
    int n1,n2;
    int mcd = 1,mcm;
    int *pn1,*pn2;
    int d1[100],d2[100];

    // INPUT dei due interi

    printf("Inserisci il primo numero :");
    scanf(" %d", &n1);
    printf("\nInserisci il secondo numero :");
    scanf(" %d", &n2);

    // calcolo divisori del primo e del secondo numero e li assegno ai relativi array

    pn1 = calcolaDivisori(n1);
    if (!pn1) return 1;
    pn2 = …

我有 ubuntu 服务器，有 8 GB RAM。当我尝试将堆大小设置为 8GB 时，我的 Web 服务器（weblogic）无法启动。但如果我将交换大小增加到 11 GB，网络服务器就会启动。

所以我的问题是，在增加交换大小后，如何为我的 Web 服务器分配 8GB 堆大小（当我有 8 GB RAM，操作系统需要其中 1 到 2 GB 时）？

我试图将包含 1,048,578 个文件的目录复制到hdfs文件系统中，但是出现以下错误：

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
    at java.util.Arrays.copyOf(Arrays.java:2367)
    at java.lang.AbstractStringBuilder.expandCapacity(AbstractStringBuilder.java:130)
    at java.lang.AbstractStringBuilder.ensureCapacityInternal(AbstractStringBuilder.java:114)
    at java.lang.AbstractStringBuilder.append(AbstractStringBuilder.java:415)
    at java.lang.StringBuffer.append(StringBuffer.java:237)
    at java.net.URI.appendSchemeSpecificPart(URI.java:1892)
    at java.net.URI.toString(URI.java:1922)
    at java.net.URI.<init>(URI.java:749)
    at org.apache.hadoop.fs.shell.PathData.stringToUri(PathData.java:565)
    at org.apache.hadoop.fs.shell.PathData.<init>(PathData.java:151)
    at org.apache.hadoop.fs.shell.PathData.getDirectoryContents(PathData.java:273)
    at org.apache.hadoop.fs.shell.Command.recursePath(Command.java:347)
    at org.apache.hadoop.fs.shell.CommandWithDestination.recursePath(CommandWithDestination.java:291)
    at org.apache.hadoop.fs.shell.Command.processPaths(Command.java:308)
    at org.apache.hadoop.fs.shell.Command.processPathArgument(Command.java:278)
    at org.apache.hadoop.fs.shell.CommandWithDestination.processPathArgument(CommandWithDestination.java:243)
    at org.apache.hadoop.fs.shell.Command.processArgument(Command.java:260)
    at org.apache.hadoop.fs.shell.Command.processArguments(Command.java:244)
    at org.apache.hadoop.fs.shell.CommandWithDestination.processArguments(CommandWithDestination.java:220)
    at org.apache.hadoop.fs.shell.CopyCommands$Put.processArguments(CopyCommands.java:267)
    at org.apache.hadoop.fs.shell.Command.processRawArguments(Command.java:190)
    at org.apache.hadoop.fs.shell.Command.run(Command.java:154)
    at org.apache.hadoop.fs.FsShell.run(FsShell.java:287)
    at org.apache.hadoop.util.ToolRunner.run(ToolRunner.java:70)
    at org.apache.hadoop.util.ToolRunner.run(ToolRunner.java:84)
    at org.apache.hadoop.fs.FsShell.main(FsShell.java:340)

在我的 Spark 程序中，我对分配和使用 Java 垃圾收集器未触及的数据感兴趣。基本上，我想像在 C++ 中那样自己对此类数据进行内存管理。这是使用堆外内存的好例子吗？其次，如何在 Java 或 Scala 中读写堆外内存。我尝试寻找示例，但找不到任何示例。

someVoid()如果我没有错误地引用传递给它的列表，那么当该方法发生调用时。代码添加后，列表中的2个值和大小相应地变为2。这里的一切对我来说都是可以理解的（如果我犯了错误，请纠正我）。AftersomeVoid()方法将列表的引用更改为null. 问题是：为什么经过这些操作后，列表的大小仍然是2？提前致谢。

public class Test {
          List<Integer> list;
        
          public Test() {
            this.list = new ArrayList<>();
            someVoid(list);
          }
        
          private void someVoid(List<Integer> list) {
            list.add(0);
            list.add(1);
            list = null;
          }
        
          public static void main(String[] args) {
            Test test = new Test();
            System.out.println("Size is: " + test.list.size());
          }
}

我在这里有一个这个问题：

function main()
    b = UInt8[0x35, 0x30, 0x2e, 0x30] # This is "50.0" in bytes
    s = parse(Float64, String(b))
end
@btime main()

250.269 ns (2 allocations: 128 bytes)
50.0

我有一个 UInt8 数组，其中包含一个字符串格式的数字，例如“50.0”。我想将这个数字解析为一个浮点数而不分配并且尽可能快（我有数百万个这些数字要解析）。有没有比我上面产生的方法更好的方法（忽略 UInt8 数组的分配，因为它不存在）。

干杯伙计们！