Java 힙과 로컬 메모리 중 어느 것이 더 빠릅니까?

Java를 사용하면 메모리 할당을 관리하고 메모리를 해제할 필요가 없다는 장점이 있습니다. new 키워드를 사용하여 객체를 인스턴스화하면 필요한 메모리가 Java 힙에 자동으로 할당됩니다. 힙은 가비지 수집기에 의해 관리되며 개체가 범위를 벗어나면 메모리를 회수합니다. 그러나 JVM에는 힙에 없는 기본 메모리에 액세스할 수 있는 '백도어'가 있습니다. 이 기사에서는 객체가 연속 바이트코드로 메모리에 저장되는 방법을 보여주고, 이러한 바이트가 Java 힙 또는 로컬 메모리에 저장되는 방법을 설명합니다. 마지막으로 JVM에서 메모리에 더 빠르게 액세스하는 방법(Java 힙 또는 로컬 메모리 사용)에 대해 몇 가지 결론을 내릴 것입니다.

Unsafe을 사용하여 메모리 할당 및 할당 해제

sun.misc.Unsafe를 사용하면 C 언어의 malloc 및 free과 마찬가지로 Java에서 로컬 메모리를 할당 및 할당 해제할 수 있습니다. 이를 통해 할당된 메모리는 자바 힙에 없고 가비지 컬렉터에서 관리하지 않기 때문에 다 소진되면 직접 해제하고 재활용하는 책임을 져야 한다. 다음은 로컬 메모리를 관리하기 위해 Unsafe를 사용하여 작성한 도구 클래스입니다.

public class Direct implements Memory {

    private static Unsafe unsafe;
    private static boolean AVAILABLE = false;

    static {
        try {
            Field field = Unsafe.class.getDeclaredField("theUnsafe");
            field.setAccessible(true);
            unsafe = (Unsafe)field.get(null);
            AVAILABLE = true;
        } catch(Exception e) {
            // NOOP: throw exception later when allocating memory
        }
    }

    public static boolean isAvailable() {
        return AVAILABLE;
    }

    private static Direct INSTANCE = null;

    public static Memory getInstance() {
        if (INSTANCE == null) {
            INSTANCE = new Direct();
        }
        return INSTANCE;
    }

    private Direct() {

    }

    @Override
    public long alloc(long size) {
        if (!AVAILABLE) {
            throw new IllegalStateException("sun.misc.Unsafe is not accessible!");
        }
        return unsafe.allocateMemory(size);
    }

    @Override
    public void free(long address) {
        unsafe.freeMemory(address);
    }

    @Override
    public final long getLong(long address) {
        return unsafe.getLong(address);
    }

    @Override
    public final void putLong(long address, long value) {
        unsafe.putLong(address, value);
    }

    @Override
    public final int getInt(long address) {
        return unsafe.getInt(address);
    }

    @Override
    public final void putInt(long address, int value) {
        unsafe.putInt(address, value);
    }
}

로컬 메모리에 객체 할당

다음 Java 객체를 로컬 메모리에 넣겠습니다.

public class SomeObject {

    private long someLong;
    private int someInt;

    public long getSomeLong() {
        return someLong;
    }
    public void setSomeLong(long someLong) {
        this.someLong = someLong;
    }
    public int getSomeInt() {
        return someInt;
    }
    public void setSomeInt(int someInt) {
        this.someInt = someInt;
    }
}

우리가 한 일은 객체의 속성 을 Memory에 넣은 것뿐입니다:

public class SomeMemoryObject {

    private final static int someLong_OFFSET = 0;
    private final static int someInt_OFFSET = 8;
    private final static int SIZE = 8 + 4; // one long + one int

    private long address;
    private final Memory memory;

    public SomeMemoryObject(Memory memory) {
        this.memory = memory;
        this.address = memory.alloc(SIZE);
    }

    @Override
    public void finalize() {
        memory.free(address);
    }

    public final void setSomeLong(long someLong) {
        memory.putLong(address + someLong_OFFSET, someLong);
    }

    public final long getSomeLong() {
        return memory.getLong(address + someLong_OFFSET);
    }

    public final void setSomeInt(int someInt) {
        memory.putInt(address + someInt_OFFSET, someInt);
    }

    public final int getSomeInt() {
        return memory.getInt(address + someInt_OFFSET);
    }
}

이제 두 쌍의 배열의 읽기 및 쓰기 성능을 살펴보겠습니다. : 하나는 수백만 개의 SomeObject 개체를 포함하고 다른 하나는 수백만 개의 SomeMemoryObject 개체를 포함합니다.

// with JIT:
Number of Objects:  1,000     1,000,000     10,000,000    60,000,000
Heap Avg Write:      107         2.30          2.51         2.58       
Native Avg Write:    305         6.65          5.94         5.26
Heap Avg Read:       61          0.31          0.28         0.28
Native Avg Read:     309         3.50          2.96         2.16

// without JIT: (-Xint)
Number of Objects:  1,000     1,000,000     10,000,000    60,000,000
Heap Avg Write:      104         107           105         102       
Native Avg Write:    292         293           300         297
Heap Avg Read:       59          63            60          58
Native Avg Read:     297         298           302         299

결론: JVM 장벽을 넘어 로컬 메모리를 읽는 것은 Java 힙에서 직접 메모리를 읽는 것보다 약 10배 느리고 쓰기 작업은 약 2배 느립니다. 그러나 각 SomeMemoryObject 객체가 관리하는 로컬 메모리 공간은 독립적이므로 읽기 및 쓰기 작업이 연속적이지 않다는 점에 유의해야 합니다. 그럼 연속적인 메모리 공간을 읽고 쓰는 성능을 비교해 보겠습니다.

대규모 연속 메모리 공간 액세스

이 테스트에는 힙과 대규모 연속 로컬 메모리에 동일한 테스트 데이터가 포함되어 있습니다. 그런 다음 여러 읽기 및 쓰기 작업을 수행하여 어느 것이 더 빠른지 확인합니다. 그리고 결과를 비교하기 위해 임의의 주소 액세스를 수행할 것입니다.

// with JIT and sequential access:
Number of Objects:  1,000     1,000,000     1,000,000,000
Heap Avg Write:      12          0.34           0.35 
Native Avg Write:    102         0.71           0.69 
Heap Avg Read:       12          0.29           0.28 
Native Avg Read:     110         0.32           0.32

// without JIT and sequential access: (-Xint)
Number of Objects:  1,000     1,000,000      10,000,000
Heap Avg Write:      8           8              8
Native Avg Write:    91          92             94
Heap Avg Read:       10          10             10
Native Avg Read:     91          90             94

// with JIT and random access:
Number of Objects:  1,000     1,000,000     1,000,000,000
Heap Avg Write:      61          1.01           1.12
Native Avg Write:    151         0.89           0.90 
Heap Avg Read:       59          0.89           0.92 
Native Avg Read:     156         0.78           0.84

// without JIT and random access: (-Xint)
Number of Objects:  1,000     1,000,000      10,000,000
Heap Avg Write:      55          55              55
Native Avg Write:    141         142             140
Heap Avg Read:       55          55              55 
Native Avg Read:     138         140             138

결론:연속 액세스를 수행할 때 Java 힙 메모리는 일반적으로 로컬 메모리보다 빠릅니다. 임의 주소 액세스의 경우 힙 메모리는 로컬 메모리보다 약간 느리며 연속 데이터의 큰 블록을 대상으로 하는 경우에는 크게 느리지 않습니다.

최종 결론

Java에서 로컬 메모리를 사용하는 것은 의미가 있습니다. 예를 들어 대량의 데이터(>2G)를 처리하고 가비지 수집기를 사용하지 않으려는 경우( GC) 시간. 대기 시간 관점에서 로컬 메모리에 대한 직접 액세스는 Java 힙에 액세스하는 것보다 빠르지 않습니다. JVM 장벽을 넘을 때 확실히 오버헤드가 발생하므로 이 결론은 실제로 의미가 있습니다. 이 결론은 로컬을 사용하든 힙을 사용하든 ByteBuffer에도 적용됩니다. 로컬 ByteBuffer를 사용함으로써 속도가 향상되는 것은 이러한 메모리에 접근하는 것이 아니라 운영체제에서 제공하는 로컬 IO로 직접 동작할 수 있다는 점입니다

위 내용은 Java 힙과 로컬 메모리 중 어느 것이 더 빠릅니까?의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!