[java] Java에서는 int 대신 byte 또는 short를 사용하고 double 대신 float를 사용하는 것이 더 효율적입니까?

이는 JVM의 구현과 기본 하드웨어에 따라 다릅니다. 대부분의 최신 하드웨어는 메모리 (또는 첫 번째 레벨 캐시에서도)에서 단일 바이트를 가져 오지 않습니다. 즉, 더 작은 기본 유형을 사용한다고해서 일반적으로 메모리 대역폭 소비가 줄어들지 않습니다. 마찬가지로 최신 CPU의 워드 크기는 64 비트입니다. 더 적은 비트에 대해 작업을 수행 할 수 있지만 여분의 비트를 버리는 방식으로 작동하지만 빠르지도 않습니다.

유일한 이점은 더 작은 기본 유형이 더 컴팩트 한 메모리 레이아웃을 생성 할 수 있다는 것입니다. 특히 배열을 사용할 때 더욱 그렇습니다. 이는 메모리를 절약하여 참조 지역성을 개선하고 (따라서 캐시 누락 수를 줄임) 가비지 콜렉션 오버 헤드를 줄일 수 있습니다.

그러나 일반적으로 더 작은 기본 유형을 사용하는 것이 더 빠르지 않습니다.

이를 입증하려면 다음 벤치 마크를 참조하십시오.

package tools.bench;

import java.math.BigDecimal;

public abstract class Benchmark {

    final String name;

    public Benchmark(String name) {
        this.name = name;
    }

    abstract int run(int iterations) throws Throwable;

    private BigDecimal time() {
        try {
            int nextI = 1;
            int i;
            long duration;
            do {
                i = nextI;
                long start = System.nanoTime();
                run(i);
                duration = System.nanoTime() - start;
                nextI = (i << 1) | 1;
            } while (duration < 100000000 && nextI > 0);
            return new BigDecimal((duration) * 1000 / i).movePointLeft(3);
        } catch (Throwable e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public String toString() {
        return name + "\t" + time() + " ns";
    }

    public static void main(String[] args) throws Exception {
        Benchmark[] benchmarks = {
            new Benchmark("int multiplication") {
                @Override int run(int iterations) throws Throwable {
                    int x = 1;
                    for (int i = 0; i < iterations; i++) {
                        x *= 3;
                    }
                    return x;
                }
            },
            new Benchmark("short multiplication") {
                @Override int run(int iterations) throws Throwable {
                    short x = 0;
                    for (int i = 0; i < iterations; i++) {
                        x *= 3;
                    }
                    return x;
                }
            },
            new Benchmark("byte multiplication") {
                @Override int run(int iterations) throws Throwable {
                    byte x = 0;
                    for (int i = 0; i < iterations; i++) {
                        x *= 3;
                    }
                    return x;
                }
            },
            new Benchmark("int[] traversal") {
                @Override int run(int iterations) throws Throwable {
                    int[] x = new int[iterations];
                    for (int i = 0; i < iterations; i++) {
                        x[i] = i;
                    }
                    return x[x[0]];
                }
            },
            new Benchmark("short[] traversal") {
                @Override int run(int iterations) throws Throwable {
                    short[] x = new short[iterations];
                    for (int i = 0; i < iterations; i++) {
                        x[i] = (short) i;
                    }
                    return x[x[0]];
                }
            },
            new Benchmark("byte[] traversal") {
                @Override int run(int iterations) throws Throwable {
                    byte[] x = new byte[iterations];
                    for (int i = 0; i < iterations; i++) {
                        x[i] = (byte) i;
                    }
                    return x[x[0]];
                }
            },
        };
        for (Benchmark bm : benchmarks) {
            System.out.println(bm);
        }
    }
}

내 다소 오래된 노트북에 인쇄됩니다 (열을 조정하기 위해 공백 추가).

int       multiplication    1.530 ns
short     multiplication    2.105 ns
byte      multiplication    2.483 ns
int[]     traversal         5.347 ns
short[]   traversal         4.760 ns
byte[]    traversal         2.064 ns

보시다시피 성능 차이는 매우 작습니다. 알고리즘 최적화는 기본 유형을 선택하는 것보다 훨씬 더 중요합니다.