수학과의 개발자 도전기

요약

인수 개수가 일정하지 않은 메서드를 정의해야 한다면 가변인수를 사용하라

가변인수 사용은 성능 문제에 영향을 미치므로 신중히 사용하자

가변인수 메서드란?

고정된 매개변수의 수를 받는 것이 아닌 명시한 타입의 인수를 0개 이상으로 가변적으로 인수를 받을 수 있는 메서드이다. 인수 개수가 정해지지 않은 경우에 가변인수는 유용하게 사용할 수 있다.

가변인수 메서드 동작 순서

1. 인수의 개수와 길이가 같은 배열을 생성한다.
2. 인수들을 배열에 저장한다.
3. 배열을 가변인수 메서드에 전달한다.

예시

static int sum(int... args) {
	int sum = 0;
	for (int arg : args) {
	  sum += arg;
	}
	return sum;
}

// sum(1,2,3)은 6을 반환하고, sum()은 0을 반환한다

예외

인수가 무조건 1개 이상이어야 할 때도 있는데, 최솟값을 찾는 메서드가 해당된다. 참고로 인수개수는 런타임에 자동 생성된 배열의 길이로 알 수 있다.

1) 문제되는 코드

static int min(int... args) {
    if (args.length == 0) {
        throw new IllegalArgumentException("인수가 1개 이상 필요합니다.");
    }

    int min = args[0];
    for (int i = 1; i < args.length; i++) {
        if (args[i] < min) {
            min = args[i];
        }
    }
    return min;
}

• 위 코드로 인수가 0개인 상황을 확인할 수 있지만, 2가지 문제점이 있다.
  • 인수가 0개일 때 유효성 검사가 컴파일 타임이 아닌 런타임 실패인 것
  • 코드가 지저분한 것
    • 매개변수 유효성 검사가 명시적이고, for-each문을 사용하기가 어렵다.

2) 더 나은 코드

static int min(int firstArg, int... remainingArgs) {
    int min = firstArg;
    for (int remainingArg : remainingArgs) {
        if (remainingArg < min) {
            min = remainingArg;
        }
    }
    return min;
}

• 첫 번째로는 일반 매개변수(가변인수에서 첫번째 인수)를 받고, 두번째로 가변인수를 받으면 이전의 문제가 사라진 깔끔한 코드를 작성할 수 있다.

성능

가변인수 메서드는 호출될 때마다 배열을 새로 하나 할당하고 초기화하기 때문에 성능에 민감한 상황에서는 걸림돌이 될 수 있다. 만약 가변인수의 유연성이 필요하지만 비용을 감당하기가 어려울 때 사용할 수 있는 방법이 있다.

예시 - 다중정의

해당 메서드 호출의 95%가 인수를 3개 이하로 사용한다고 가정하면, 다음과 같이 메서드 다중정의를 할 수 있다.이 방법은 혹시나 4개 이상의 인수를 받아야할 상황에 도움이 될 수 있다.

예시로 EnumSet이 있는데, EnumSet은 비트필드를 대체하면서 성능까지 유지해야 하므로 이 기법으로 정적 팩터리를 생성하면 열거 타입 집합 생성 비용을 최소화한다.

주의) 가변인수는 메서드 파라미터 마지막에 위치해야한다.

public void foo() { }
public void foo(int a1) { }
public void foo(int a1, int a2) { }
public void foo(int a1, int a2, int a3) { }
public void foo(int a1, int a2, int a3, int... rest) { } // 5%만 적용

요약

메서드 매개변수 수가 같을 때는 다중정의(overloading)는 되도록 하지 말자
(사용자 입장에서 어느 메서드를 사용하는지 혼란을 줄 수 있기 때문이다).

만약 다중정의를 해야한다면
1)형변환을 하거나
2) 인수 포워드 등을
통해 같은 객체를 받는 다중 정의 메서드들이 모두 동일하게 동작하도록 만들어야 한다.

1. 다중정의의 오류

1-1. 다중정의 메서드는 정적 선택

public class CollectionClassifier {

    public static String classify(Set<?> c) {
        return "집합";
    }

    public static String classify(List<?> c) {
        return "리스트";
    }

    public static String classify(Collection<?> c) {
        return "그 외";
    }

    public static void main(String[] args) {
        Collection<?>[] collections = {
                new HashSet<String>(),
                new ArrayList<BigInteger>(),
                new HashMap<String, String>().values()
        };

        for (Collection<?> c : collections) {
            System.out.println(classify(c));
        }
    }
}

위 코드 main()을 실행하면 ’집합’, ‘리스트’, ‘그 외’가 출력될 것이라 예상하지만 실제로는 ’그 외’, ‘그 외’, ‘그 외’가 출력된다. 그 이유는 다중정의 메서드 중 어떤 메서드를 호출할지가 컴파일 타임에, 매개변수의 컴파일타임 타입에 의해서만 정해지기 때문이다. 컴파일타임에는 for 문 안의 c는 항상 Collection<?> 타입이다. 그렇기에 세번째 classify()가 호출되어 모두 ‘그 외’가 출력이 되는 것이다.

1-2. 해결책

위 코드를 의도한대로 출력하게 하기 위해서는 모든 classify 메서드를 하나로 합친 후, instanceof로 명시적으로 검사하면 해결된다.

public static String classify(Collection<?> c) {
    return c instanceof Set ? "집합":
           c instanceof List ? "리스트" : "그 외";
}

1-3. 재정의 메서드는 동적 선택

class Wine {
    String name() { return "포도주"; }
}

class SparklingWine extends Wine {
    @Override String name() { return "발포성 포도주"; }
}

class Champagne extends SparklingWine {
    @Override String name() { return "샴페인"; }
}

public class Overriding {
    public static void main(String[] args) {
        List<Wine> windList = List.of(
                new Wine(), new SparklingWine(), new Champagne());

        for (Wine wine : windList) {
            System.out.println(wine.name());
        }
    }
}

반면 재정의(override) 메서드는 런타임에서 동적으로 선택되기 때문에 위 예시에서는 “포도주”, “발포성 포도주”, “샴페인”으로 예상한 값과 동일하게 출력된다.

2. 다중정의 사용법

위의 내용으로 다중정의 메서드 작성 시 헷갈릴 수 있는 코드는 작성하지 않는 게 좋다.

특히 오픈 API라면 더욱 신경 써야 한다. API 사용자가 매개변수를 넘기면서 어떤 다중정의 메서드가 호출될지를 모른다면 프로그램이 오작동하기 쉬워 런타임에 이상하게 행동해 API 사용자로 하여금 혼란을 줄 수 있다.

2-1. 가이드라인

안전하고 보수적으로 가려면 다음과 같은 가이드라인을 따르는 것을 권장한다.

• 매개변수 수가 같은 다중정의는 만들지 말자
• 가변인수(varargs)를 사용하는 메서드라면 다중정의를 아예 하지 말아야 한다
• 되도록이면 다중정의 대신 메서드 이름을 다르게 짓는 것도 방법이 될 수 있다
  • 예시로는 ObjectOutputStream이 있다. write 메서드의 매개변수에 따라 writeBoolean(boolean), writeInt(int), readBoolean(), readInt() 형식으로 메서드를 구분한다.

2-2. 생성자

생성자 같은 경우는 이름을 다르게 지을 수 없으니 두 번째 생성자부터는 무조건 다중정의가 된다.

이 문제는 1)정적팩터리를 사용하거나 2) 매개변수간 형변환을 할 수 없는 다중정의 메서드(예시로 ArrayList에는 ArrayList(int) 생성자와 ArrayList(<Collection>) 생성자가 있다. int와 Collection은 완전히 다르므로 메서드 호출에 혼동이 생길 일은 없다)를 만들어서 해결할 수 있다.

2-3. 인수 포워드

인수 포워드는 상대적으로 더 특수한 다중정의 메서드에서 더 일반적인 다중정의 메서드로 일을 넘겨버리는 것(forward)을 의미한다.

public boolean contentEquals(StringBuffer sb) {
	return contentEquals((CharSequence) sb);
}

3. 자바5 버전 이후 다중 정의 문제

3-1. 제네릭, 오토박싱 으로 인한 문제

public class SetList {

    public static void main(String[] args) {
        Set<Integer> set = new TreeSet<>();
        List<Integer> list = new ArrayList<>();

				// -3 ~ 2 까지 정수 삽입
        for (int i = -3; i < 3; i++) {
            set.add(i); 
            list.add(i);
        }

        for (int i = 0; i < 3; i++) {
            set.remove(i);
            list.remove(i);
        }

        System.out.println(set + " " + list);
    }
}

// 예상 출력 결과
[-3, -2, -1] [-3,-2,-1]

// 실제 출력 결과
[-3, -2, -1] [-2, 0, 2]

예상과 다른 출력이 발생한 이유는 list.remove()의 다중정의 때문이다. set.remove(i)의 시그니처는 remove(Object)인 반면, list.remove(i)의 시그니처는 다중정의된 remove(int index)(List<E> 인터페이스는 remove(Object)와 remove(int)를 다중정의 함)를 선택한다. 따라서 list의 경우 각 단계마다 0번째, 1번째, 2번째의 원소를 제거한다. 따라서 [-3, -2, -1] 이 아닌 [-2, 0, 2]가 출력된다.

• 해결

  for (int i = 0; i < 3; i++) {
  	set.remove(i);
  	list.remove((Integer) i); // 혹은 list.remove(Integer.valueOf(i))
  }
  

• 위 문제 해결은 list.remove()에서 int를 Integer로 형변환하면 된다.

3-2. 람다, 메서드 참조로 인한 문제

// 1번. Thread 생성자 호출
new Thread(System.out::println).start();

// 2번. ExecutorService의 submit 메서드 호출
ExecutorService exec = Executors.newCachedThreadPool();
exec.submit(System.out::println);

// 결과 : 1번은 정상작동 하지만, 2번은 정상 작동하지 않는다.

각 함수에 넘겨진 인수는 System.out::println으로 동일하고, 양쪽 모두 Runnable을 받는 형제 메서드를 다중정의하고 있다. 그런데 왜 2번만 실패하는 것일까? 이유는 submit도 다중정의(submit 다중 메서드 중에는 Callable<T>를 받는 메서드가 있기 때문)되어 있고, println도 다중정의(적절한 다중정의 메서드를 찾는 알고리즘) 되어 있기에 다중정의 해소 알고리즘이 우리의 기대(println은 void를 반환하니, 반환값이 있는 Callable과 헷갈리지 않을 것이기에 정상동작할 것이다.)처럼 동작하지 않기 때문이다.

→ 다중정의된 메서드(혹은 생성자)들이 함수형 인터페이스를 인수로 받을 때, 비록 서로 다른 함수형 인터페이스라도 인수 위치가 같으면 혼란이 생긴다는 것이다.

→ 따라서, 서로 다른 함수형 인터페이스라도 같은 위치의 인수로 받아서는 안 된다.(서로 다른 함수형 인터페이스라도 서로 근본적으로 다르지 않다는 뜻)

4. 예외

다중정의된 메서드라도 같은 동작을 하면 상관없지만, 예외가 있는데 String 클래스의 valueOf(char[])과 valueOf(Object)는 같은 객체를 건네더라도 전혀 다른 일을 수행한다.

요약

방어적 복사를 해야하는 경우와 할 필요가 없는 경우는 다음과 같다.

방어적 복사를 해야하는 경우

• 클라이언트로 반환하거나 클라이언트로 받는 구성요소가 가변일 때
• 객체의 잠재적 변경 가능성이 있고, 변경이 되면 안되는 경우

방어적 복사를 할 필요가 없는 경우

• 성능 저하가 예상되는 경우 (ex. 매개변수 복사 비용이 너무 클 때)
• 클라이언트가 구성요소를 수정할 일이 없다는 신뢰가 있는 경우
• 불변식이 깨지더라도 그 영향이 호출한 클라이언트로 국한되는 경우 (ex. 래퍼 클래스)

→ 이런 경우에는 구성요소에 대한 변경의 책임이 클라이언트에 있음을 문서화 하자

불변식을 지키는 코드 작성

코드를 작성할 때, 외부 클라이언트가 내부 클래스를 수정하지 못하도록 보호하는 코드를 작성해야 한다. 이는 곧 클래스의 캡슐화를 구현하는 방법이다.

불변식을 지키지 못한 예시

public class Period1 {
    private final Date start;
    private final Date end;

    public Period1(Date start, Date end) {
        if (start.compareTo(end) > 0) {
            throw new IllegalArgumentException(
                    start + "가 " + end + "보다 늦다.");
        }
        this.start = start;
        this.end = end;
    }
    
    public Date start() { return start; }
    
    public Date end() { return end; }
}

// Period 인스턴스 내부 공격
Date start = new Date();
Date end = new Date();
Period p = new Period(start, end);
end.setYear(78); // period 인스턴스 값 수정

• 언뜻 보기에는 불변식이 지켜질 것 같지만, 실제로는 Date가 가변 객체이기 때문에 외부에서 start, end를 수정할 수 있어 불변식을 깨는 코드이다.
• 따라서 Date 대신 Instant, LocalDateTime, ZonedDateTime을 사용해야 한다.

새로운 코드는 Date 외 다른 객체를 사용하면 되지만, 예전에 작성된 낡은 코드에 Date가 있을 때에는 방어적 복사로 대처할 수 있다.

방어적 복사

외부 공격으로부터 인스턴스 내부를 보호하기 위해서는 생성자에서 받은 가변 매개변수 각각을 방어적 복사 해야 한다.

예시1 - 생성자 방어적 복사

public Period2(Date start, Date end) {
	// 1. 방어적 복사 
	this.start = new Date(start.getTime()); // 매개변수 start 방어적 복사
	this.end = new Date(end.getTime()); // 매개변수 end 방어적 복사
        
        // 2. 매개변수의 유효성 검사
	if (start.compareTo(end) > 0) {
		throw new IllegalArgumentException(
				start + "가 " + end + "보다 늦다.");
  }
}

방어적 복사 시 주의할 점

• 순서
  1. 방어적 복사본을 먼저 만든다.
  2. 매개변수의 유효성 검사 수행 (아이템49)
  → 위 순서대로 해야하는데, 그 이유는 유효성 검사를 한 후 복사본을 만드는 그 순간에 다른 스레드가 원본 객체를 수정할 위험이 있기 때문이다. 반대가 되면 안된다.
• clone()
  • 매개변수가 제3자에 의해 확장될 수 있는 타입일 경우, 방어적 복사본을 만들 때 clone() 메서드를 사용하면 안된다
  • 다른 곳에서 정의된 clone()일 경우, 악의를 가진 하위 클래스의 인스턴스가 반환될 가능성이 있기 때문이다

예시2 - 접근자 방어적 복사

예시1을 통해 생성자에 대한 공격은 예방했지만, 아직 접근자는 내부 가변 정보(Date객체)를 직접 반환하기 때문에 Period2 인스턴스는 변경가능하다.

public Date start() { return new Date(start.getTime()); }

public Date end() {return new Date(end.getTime()); }

• 직접 가변 필드(start, end)를 반환하는 것이 아닌 가변 필드의 방어적 복사본을 반환하면 Period2 인스턴스를 변경하는 방법은 없다.
• 즉 모든 필드가 객체 안에 완벽하게 캡슐화 되었다

방어적 복사가 필요한 경우

1. 불변객체를 만들어야 하는 경우
2. 객체의 잠재적 변경 가능성이 있고, 변경이 되면 안되는 경우
   1. 객체의 잠재적 변경 가능성이 있고 변경이 되어도 문제 없다면 방어적 복사를 꼭 하지 않아도 된다
3. 가변인 내부 객체를 클라이언트에 반환 하는 경우
   1. 원본을 노출하지 말고 방어적 복사본을 반환함으로써 혹시 모를 원본 객체 변경 상황을 예방할 수 있다
   2. 길이가 1이상인 배열은 무조건 가변이기에 배열은 항상 방아적 복사를 하거나 배열의 불변 뷰를 반환해야 한다

코틀린 → 불변, Null 관련 해서 잘 되어 있음

요약

스트림 병렬화를 사용하려면 신중해야 한다.
운영 환경과 유사한 조건에서 테스트 했을 때, 올바른 계산 수행을 하고 성능 향상이 확인된 경우에만 사용해야한다.

스트림 병렬화 사용이 부적절한 경우

• Stream 병렬화 적용 안 한 코드
  • 스트림을 사용해 처음 20개의 메르센 소수를 생성하는 프로그램
  • 12.5초 걸림

      
      public static void main(String[] args) {
          primes().map(p -> TWO.pow(p.intValueExact()).subtract(ONE))
                  .filter(mersenne -> mersenne.isProbablePrime(50))
                  .limit(20) // 병렬화 성능 저하 이유2
                  .forEach(System.out::println);
      }
  
      static Stream<BigInteger> primes() {
          return Stream.iterate(TWO, BigInteger::nextProbablePrime); // 병렬화 성능 저하 이유1
      }
  

• Stream 병렬화(parallel()) 적용 → 파이프라인을 병렬화하는 방법을 찾아내지 못하기 때문이다.
• 위 코드에 parallel()을 적용하면 성능이 더 좋아질 것 같지만, 실상은 무한으로 코드가 실행되고 아무것도 출력되지 못한다. 또한 병렬화에서 성능 개선을 기대할 수 없는데, 그 이유는 다음과 같다.

1. Stream.iterate 사용
   1. 무한 스트림을 제공하기 때문에 무한으로 실행됨. 무한 스트림은 병렬화에서 나눠서 진행(포크-조인). 무한이면 몇 개로 나눠야 할지 모르기 때문에 느려짐
2. 중간 연산으로 limit() 사용
   1. limit은 요소 순서에 의존하기 때문에 병렬화가 의미가 없음

따라서 스트림 파이프라인을 마구잡이로 병렬화하면 안된다. 무분별하게 사용하면 성능이 오히려 나빠질 수 있다.

스트림 병렬화 사용이 적합한 경우

1. 병렬시 스트림 소스로 사용하면 좋은 자료구조

• ArrayList, HashMap, HashSet, ConcurrentHashMap의 인스턴스
• 배열, int 범위, long 범위
• 이유
  • 모두 데이터를 원하는 크기로 정확하고 손쉽게 나눌 수 있다
    • 따라서 일을 다수의 스레드에 분배하기 좋다
  • 원소들을 순차적으로 실행할 때 참조 지역성이 뛰어나다
    • 이웃한 원소의 참조들이 메모리에 연속해서 저장되어 있음을 의미
    • 참조 지역성은 벌크 연산에서 병렬화할 때 중요하다
    • 참조 지역성이 가장 뛰어난 자료구조는 배열

2. 종단 연산 - 축소

종단 연산에서 연산량이 적어야 병렬 수행 효율이 좋은데, 축소 작업을 사용하면 된다. 축소는 파이프라인에서 만들어진 모든 원소를 하나로 합치는 작업이다. 예시로는 Stream reduce 메서드, min, max, count, sum, anyMatch, allMatch, noneMatch 등이 있다.

반면에 가변 축소를 수행하는 Stream의 collect 메서드는 컬렉션들을 합치는 부담이 크기 때문에 병렬화에 적합하지 않다. + 순서에 의존하는 함수(limit, first 등)

3. (스트림 원소 개수) * (각 원소의 코드라인 수) ≥ 수십만

스트림 병렬화는 오직 성능 최적화 수단임을 알아야 하는데, 적용 전후로 반드시 성능을 테스트해 병렬화를 사용할 가치가 있는지 확인해야 한다. 그 기준으로 스트림 병렬화는 (스트림 원소 개수) * (각 원소의 코드라인 수) ≥ 수십만이 되어야 성능 향상을 기대할 수 있다.

정리

스트림 병렬화의 장점

조건만 잘 갖춰진다면 parallel() 호출 하나로 큰 성능 향상을 경험할 수 있다.

예시 : n이하의 소수 개수 구하기

• parallel 적용 전 : 31초

static long pi(long n) { 
    return LongStream.rangeClosed(2, n) 
                     .mapToObj(BigInteger::valueOf) 
                     .filter(i -> i.isProbablePrime(50)) 
                     .count(); 
}

• parallel 적용 후 : 9.2초

static long piParallel(long n) { 
    return LongStream.rangeClosed(2, n) // LongStream : 기본 타입 long을 스트림함, 박싱/언박싱 필요 없어서 성능 최적화 
                     .parallel() 
                     .mapToObj(BigInteger::valueOf) 
                     .filter(i -> i.isProbablePrime(50)) 
                     .count(); 
}

스트림 병렬화의 단점

스트림을 잘못 병렬화하면 응답 불가, 성능 저하를 넘어서 결과 자체가 잘못되거나 예상하지 못한 동작이 발생할 수 있기 때문에 사용에 신중해야 한다.

💡 병렬 스트림 파이프라인을 공통의 포크-조인 풀에서 수행되므로(같은 스레드 풀을 사용하므로), 잘못된 파이프라인 하나가 시스템의 다른 부분의 성능에까지 악영향을 줄 수 있음을 유념하자.

💡 참조 지역성 떨어짐 + 크기가 변하는 링크드 리스트는 쓰면 안됨!!

💡 기본 타입의 스트림을 사용하는 것이 최적화에 더 좋다!