[Java] 박싱(Boxing), 언박싱(Unboxing)으로 인해 발생할 수 있는 성능 이슈

출처

ChatGPT

---

1. 박싱(Boxing)과 언박싱(Unboxing)이란?

박싱 Boxing

원시 타입 데이터를 그에 대응하는 레퍼 클래스 객체로 변환하는 과정. 예를 들어, int를 Integer로 변환한다.

언박싱 Unboxing

래퍼 클래스 객체를 다시 원시 타입으로 변환하는 과정. 예를 들어, Integer 객체를 int 값으로 변환한다.

 

자바에서는 이러한 변환이 자동으로 이뤄지기 때문에 오토박싱(Auto-Boxing)과 오토언박싱(Auto-Unboxing)이라고도 부른다.

 

예시

int num = 10;  // 원시 타입
Integer boxedNum = num;  // 오토박싱: int -> Integer
int unboxedNum = boxedNum;  // 오토언박싱: Integer -> int

 

2. 박싱과 언박싱으로 인한 성능 이슈

1. 메모리 할당과 GC(가비지 컬랙션) 오버헤드

메모리 할당

박싱을 수행할 때마다 새로은 객체가 힙 메모리에 생성된다. 예를 들어, int 값을 Integer 객체로 변환하면 힙 메모리에 새로운 Integer 객체가 생성된다. 이 추가적인 객체 생성은 메모리 사용량을 증가시키고, 특히 반복문에서 많은 수의 박싱이 발생할 경우 성능에 큰 영향을 미칠 수 있다.

가비지 컬렉션 Garbage Collection

박싱된 객체는 참조가 없어지면 가비지 컬렉션 대상이 된다. 많은 수의 박싱된 객체가 생성되고 소멸되면, 가비지 컬렉션이 더 자주 발생하게 되어 성능에 부정적인 영향을 미칠 수 있다.

 

2. 연산 성능 저하

추가 연산

박싱과 언박싱은 추가적인 연산을 요구한다. 예를 들어, Integer 객체를 int로 변환하는 언박싱 과정에서는 메모리에서 객체 참조를 따라가서 실제 int 값을 추출하는 비용이 발생한다. 반복적으로 이 작이 수행되면 성능이 저하될 수 있다.

 

3. 캐싱(Caching) 오버헤드

자바는 -128에서 127 사이의 Integer 객체는 자주 사용되기 때문에 캐싱을 한다. 이 범위 내의 값은 새로운 객체를 생성하지 않고 캐시된 객체를 재사용한다. 그러나 이 범위를 벗어난 값에 대해서는 새로운 객체가 생성되므로, 캐시 범위 바깥의 값들에 대해서는 성능 이슈가 발생할 수 있다.

 

3. 박싱과 언박싱으로 인한 성능 문제를 피하기 위한 방법

1. 원시 타입 배열 사용

제네릭을 사용하는 경우 원시 타입을 사용할 수 없으므로, 대신 원시 타입 배열을 사용하는 것이 성능에 유리할 수 있다.

int[] numbers = new int[100];  // 원시 타입 배열

 

2. Stream API의 IntStream, LongStream, DoubleStream 사용

자바 8 이상에서는 Stream API를 사용할 때, 원시 타입을 위한 특별한 스트림을 제공한다. IntStream, LongStream, DoubleStream 등은 박싱과 언박싱을 피하면서 원시 타입의 스트림 연산을 수행할 수 있게 한다.

IntStream.range(1, 100).forEach(System.out::println);

 

3. 기본적으로 레퍼 클래스 대신 원시 타입 사용

가능한 경우, 래퍼 클래스 (Integer, Double 등) 대신 원시 타입(int, double 등)을 사용하는 것이 성능에 더 유리하다

 

4. 컬렉션에 너무 많은 레퍼 타입 사용을 피하기

컬렉션이나 제네릭 클래스에 수많은 원시 타입 값을 래핑해서 저장하지 않도록 주의해야 한다. 가능한 경우, 컬렉션의 사용을 줄이거나, 원시 타입 전용 컬렉션을 사용하는 것이 좋다.

 

4. 실제적인 예시 코드

다음 코드는 제네릭 List를 사용하여 Integer 값을 저장하는 경우와 원시 타입 배열을 사용하는 경우의 성능 차이를 비교하는 간단한 예제이다.

import java.util.ArrayList;
import java.util.List;

public class BoxingExample {
    public static void main(String[] args) {
        // 제네릭 List와 래퍼 클래스 Integer를 사용하는 경우
        List<Integer> numbers = new ArrayList<>();
        long start = System.nanoTime();
        for (int i = 0; i < 1_000_000; i++) {
            numbers.add(i);  // 오토박싱 발생
        }
        long end = System.nanoTime();
        System.out.println("Time taken with List<Integer>: " + (end - start) + " ns");

        // 원시 타입 배열을 사용하는 경우
        int[] numbersArray = new int[1_000_000];
        start = System.nanoTime();
        for (int i = 0; i < 1_000_000; i++) {
            numbersArray[i] = i;  // 오토박싱 없음
        }
        end = System.nanoTime();
        System.out.println("Time taken with int[]: " + (end - start) + " ns");
    }
}

 

위 예제에서 List<Integer>는 오토박싱으로 인해 성능이 저하될 수 있는 반면, 원시 타입 배열인 int[]는 성능이 더 우수할 수 있다. 이 코드의 실행 결과는 시스템 환경에 따라 달라질 수 있지만, 일반적으로 int[]를 사용하는 것이 더 빠르다.