Início / coding / Perguntas / 79170030
Accepted
RRM
Asked: 2024-11-08 20:24:45 +0800 CST

Tamanho da memória da matriz Java

  • 772

Para aqueles que desejam sinalizar isso como duplicado, esta pergunta não está relacionada a nenhuma das perguntas como:

Como calcular o tamanho da memória de um array Java?

Tamanho de memória de matrizes int[] do sistema Java de 32 bits

Em Java, quando uma matriz de primitivos inté criada:

int[] arr = new int[1000];

A JVM aloca memória para todo o comprimento do array * 4 bytes, ou seja, 4000 bytes após a declaração acima? Não vamos nos preocupar com overheads constantes como cabeçalhos etc.

Meu entendimento é que no caso de tipos numéricos primitivos, por exemplo int, doubleetc., o valor padrão '0' também é um valor válido, portanto precisa de memória. Na verdade, a memória necessária completa deve ser alocada no momento de tais declarações.

Como eu poderia verificar isso?

java

3 respostas

  1. Best Answer

    Vamos ver

    public class Test {
    public static void main(String[] args) {
        for(int i = 0; i < Integer.MAX_VALUE; i++) {
            if(test(i) != i + 0x123)
                throw new AssertionError();
        }
    }
  
    static int test(int someArg) {
        int[] arr = new int[1000];
        arr[42] = someArg;
        return arr[42] + 0x123;
    }
}

    jdk-17\bin\javac -d %tmp% src\Test.java
jdk-17\bin\java -XX:CompileCommand=print,Test.test -cp %tmp% Test

    …
============================= C2-compiled nmethod ==============================
----------------------------------- Assembly -----------------------------------

…

--------------------------------------------------------------------------------

[Verified Entry Point]
  # {method} {0x0000020061400350} 'test' '(I)I' in 'Test'
  # parm0:    rdx       = int
  #           [sp+0x20]  (sp of caller)
  0x000002004e6e2f00:   sub    $0x18,%rsp
  0x000002004e6e2f07:   mov    %rbp,0x10(%rsp)
  0x000002004e6e2f0c:   mov    %edx,%eax
  0x000002004e6e2f0e:   add    $0x123,%eax
  0x000002004e6e2f14:   add    $0x10,%rsp
  0x000002004e6e2f18:   pop    %rbp
  0x000002004e6e2f19:   cmp    0x340(%r15),%rsp             ;   {poll_return}
  0x000002004e6e2f20:   ja     0x000002004e6e2f27
  0x000002004e6e2f26:   ret
  0x000002004e6e2f27:   movabs $0x2004e6e2f19,%r10          ;   {internal_word}
  0x000002004e6e2f31:   mov    %r10,0x358(%r15)
  0x000002004e6e2f38:   jmp    0x0000020046c63400           ;   {runtime_call SafepointBlob}
  0x000002004e6e2f3d:   hlt
  0x000002004e6e2f3e:   hlt
  0x000002004e6e2f3f:   hlt
[Exception Handler]
  0x000002004e6e2f40:   jmp    0x0000020046d05480           ;   {no_reloc}
[Deopt Handler Code]
  0x000002004e6e2f45:   call   0x000002004e6e2f4a
  0x000002004e6e2f4a:   subq   $0x5,(%rsp)
  0x000002004e6e2f4f:   jmp    0x0000020046c626a0           ;   {runtime_call DeoptimizationBlob}
  0x000002004e6e2f54:   hlt
  0x000002004e6e2f55:   hlt
  0x000002004e6e2f56:   hlt
  0x000002004e6e2f57:   hlt
--------------------------------------------------------------------------------

    Como podemos ver, além das instruções que lidam com a invocação do método em si (ou seja, manipulação de pilha), o código gerado pelo C2 para o testmétodo consiste em duas instruções, mov %edx,%eaxe add $0x123,%eax. Nenhuma alocação de array, nenhuma zeragem de array.

    Este é, claro, o cenário mais extremo. Mas demonstra que não há exigência de fazer o que foi escrito literalmente, desde que o comportamento resultante seja compatível.

    Além disso, o termo “alocação” é ambíguo. Ele implica em mudar alguma estrutura de dados para registrar que uma região específica da memória não está disponível para outros propósitos. Mas há diferenças em quem compartilha essa estrutura e, portanto, o mesmo ponto de vista sobre o que é alocado.

    Pequenas alocações geralmente são feitas em um TLAB que é dedicado a um único thread. Então alocar um pequeno array em um TLAB só faz diferença para aquele thread. Do ponto de vista dos outros threads, a memória daquele TLAB não estava disponível de qualquer forma. Mas mesmo quando um novo TLAB é alocado da memória heap compartilhada por todos os threads, é a memória que é considerada já reservada para o processo JVM do ponto de vista do sistema operacional. Somente quando a JVM expande ou encolhe toda a memória heap, isso afetará o que o sistema operacional reserva para a JVM (que é o que pode ter um impacto em outros processos).

    Mas mesmo quando a memória é alocada do sistema operacional, ela não precisa ser apoiada pela memória física. O sistema operacional pode adiar essa operação até o ponto em que a primeira operação de gravação real acontece. Até esse ponto, a memória ainda pode ser considerada toda preenchida com zeros, que é o padrão típico, e o sistema não precisa de memória real para uma região toda preenchida com zeros.

    • 5

  2. Sim, a JVM aloca toda a memória de uma vez.

    • 1

  3. A JVM aloca memória para todo o comprimento do array * 4 bytes, ou seja, 4000 bytes após a declaração acima

    Java fará como você diz, e mais uma coisa é que a memória precisa ser contígua. Como os dados do arrar são consecutivos, é necessário alocá-los completamente ao inicializar o array, se não houver memória contígua, out of mem ocorrerá.

    Será necessário algum espaço para o array em si, mas será apenas de 4 a 8 bytes.

    Por exemplo: alocarei vagas de estacionamento para A para acomodar 100 carros. E alocarei vagas de estacionamento para B para acomodar 50 carros logo atrás de A.

    Mesmo que A ainda não tenha todos os 100 carros, preciso saber o tamanho exato de cada carro para calcular com precisão o espaço necessário para 100 carros para estacionar A. O mesmo se aplica a B, que é o próximo depois de A.

    • -1

relate perguntas