변경 가능성을 최소화하라(불변 클래스의 장점, 단점, 단점 대처 방법)(2) - [4장. 클래스와 인터페이스(아이템17)]

  이전 글

• 변경 가능성을 최소화하라(불변 클래스를 만드는 다섯 가지 규칙)(1) - [4장. 클래스와 인터페이스(아이템17)]

  이번 글에서는 불변 클래스의 장점, 단점, 그리고 단점 대처 방법에 대해서 알아보자.

 

1. 장점 🚑

📘 장점 1. 함수형 프로그래밍에 적합하다.

public final class Complex {
    private final double re;
    private final double im;

    public Complex(double re, double im) {
        this.re = re;
        this.im = im;
    }

    public double realPart() { return re;}
    public double imaginaryPart() {return im;}

    public Complex plus(Complex c){
        return new Complex(re + c.re, im + c.im);
    }

    public Complex minus(Complex c){
        return new Complex(re - c.re, im - c.im);
    }

    public Complex times(Complex c){
        return new Complex(re * c.re - im * c.im, re*c.im + im * c.re);
    }

    public Complex dividedBy(Complex c){
        double tmp = c.re*c.re + c.im * c.im;
        return new Complex((re * c.re + im * c.im) / tmp, (im * c.re - re * c.im) / tmp);
    }

    @Override
    public boolean equals(Object o){
        if(o == this)
            return true;
        if(!(o instanceof Complex))
            return false;
        Complex c = (Complex) o;

        return Double.compare(c.re, re) == 0
                && Double.compare(c.im, im) == 0;
    }

    @Override
    public int hashCode() {
        return 31 * Double.hashCode(re) + Double.hashCode(im);
    }

    @Override
    public String toString() {
        return "(" + re + " + " + im + "i)";
    }
}

  plus, minus, times, dividedBy를 살펴보면 인스턴스 자신은 수정하지 않고 새로운 Compelx 인스턴스를 만들어 반환한다는 것을 알 수 있다. 즉, 피연산자를 수정하지 않고 결과를 반환하는 함수형 프로그래밍에 따르고 있다. 이렇게 되면 코드에서 불변이 되는 영역의 비율이 높아지는 장점을 누릴 수 있다.

📘 장점 2. 불변 객체는 단순하다.

  값이 바꿀 거라고 예상하지 않아도 되므로 프로그래밍이 더 간단해진다. 만약 값이 바뀐다고 하면, 복사를 해서 사용하거나 바뀌었다는 가정하에 프로그래밍을 해야 하므로 훨씬 복잡한 상태에 놓일 수 있다.

📘 장점 3. 불변 객체는 근본적으로 스레드 안전하여 따로 동기화할 필요 없다.

  여러 스레드가 동시에 사용해도 절대 훼손되지 않는다. 사실 클래스를 스레드 안전하게 만드는 가장 쉬운 방법이기도 하다. 

📘 장점 4. 불변 객체는 안심하고 공유할 수 있다.

  불변 클래스라면 한번 만든 인스턴스를 최대한 재활용하기를 권하고 있다. 위의 코드에서 ZERO, ONE, I처럼 상수로 선언하여 인스턴스를 재활용할 수 있다.

  또한, 불변 클래스는 자주 사용되는 인스턴스를 캐싱하여 같은 인스턴스를 중복 생성하지 않게 해주는 정적 팩터리를 제공할 수 있다. 이런 정적 팩터리를 사용하면 여러 클라이언트가 인스턴스를 공유하여 메모리 사용량과 가비지 컬렉션 비용이 줄어든다는 장점이 있다. 그리고 새로운 클래스를 설계할 때 public 생성자 대신 정적 팩터리를 만들어두면, 클라이언트를 수정하지 않고도 필요에 따라 캐시 기능을 나중에 덧붙일 수 있다.

  불변 객체를 자유롭게 공유할 수 있다는 점은 방어적 복사도 필요 없다는 결론으로 이어진다. 아무리 복사를 해도 원본과 똑같으니 복사 자체가 의미가 없다. 그러므로 불변 클래스는 clone 메서드나 복사 생성자를 제공하지 않는 게 좋다.

📘 장점 5. 불변 객체는 자유롭게 공유할 수 있음은 물론, 불변 객체끼리는 내부 데이터를 공유할 수 있다.

public class BigInteger extends Number implements Comparable<BigInteger> {
    final int signum;
    final int[] mag;
    
    public BigInteger negate() {
        return new BigInteger(this.mag, -this.signum);
    }    
}

----------

public static void main(String[] args) {
    BigInteger ten = BigInteger.TEN;
    BigInteger minusTen = ten.negate();
}

  BigInteger 클래스는 내부에서 값의 부호(sign)와 크기(mag)를 따로 표현한다. negate 메서드를 사용하면 크기는 같고 부호만 반대인 새로운 BigInteger를 생성하는데, 내부 데이터를 공유하여 생성한다.

  이때, 배열이라는 것이 가변이라서 위험하다고 생각할 수 있는데 위와 같이 final을 이용하여 불변으로 처리해 주었기 때문에 내부 데이터를 공유해도 안전하게 된다.

  불변 객체 끼리 한다는 것을 한번 더 인지하고 넘어가도록 하자.

📘 장점 6. 객체를 만들 때 불변 객체로 구성하면 이점이 많다.

  값이 바뀌지 않는 구성요소들로 이뤄진 객체라면 그 구조가 아무리 복잡하더라도 불변식을 유지하기 훨씬 수월해진다.

public class Point {

    public int y, x;

    public Point(int y, int x) {
        this.y = y;
        this.x = x;
    }
}

----------

public static void main(String[] args) {
    Set<Point> points = new HashSet<>();
    Point firstPoint = new Point(1, 2);
    points.add(firstPoint);

    firstPoint.y = 2;
}

  위와 같이 Set이 가변 객체들로 구성된다면 불변식이 너무나 쉽게 허물어진다.

public class Point {

    private final int y, x;

    public Point(int y, int x) {
        this.y = y;
        this.x = x;
    }
}

----------

public static void main(String[] args) {
    Set<Point> points = new HashSet<>();
    Point firstPoint = new Point(1, 2);
    points.add(firstPoint);
}

  하지만 불변 객체를 원소로 가진다면 불변식을 유지하기가 훨씬 수월해진다.

📘 장점 7. 실패 원자성을 제공한다.

  불변 객체를 만들면 상태가 절대 변하지 않으니 잠깐이라도 불일치 상태에 빠질 가능성이 없다. 근본적으로 실패원자성을 제공하게 된다.

  물론 가변 객체를 사용하더라도 실패 원자성을 제공할 수 있기는 하다.

 

2. 단점 🚒

📕 단점 1. 값이 다르면 반드시 독립된 객체로 만들어야 한다.

  값의 가짓수가 많다면 이들을 모두 만드는 데 큰 비용을 치러야 한다. 

BigInteger moby = ...;
moby = moby.flipBit(0);

  위와 같이 백만 비트짜리 BigInteger에서 비트 하나만 바꿔주는 경우를 살펴보자. filpBit 메서드는 새로운 BigInteger 인스턴스를 생성한다. 원본과 단지 한 비트만 다른 백만 비트짜리 인스턴스를 생성한다는 것이다. 이렇게 되면 BigInteger의 크기에 비례하여 시간과 공간을 잡아먹게 된다.

BigSet moby = ...;
moby.flip(0);

  BigSet은 BigInteger와 달리 가변 클래스이다. 이를 이용하면 원하는 비트 하나만 상수 시간(O(1))안에 바꿔주는 메서드를 사용할 수 있다.

 

3. 단점 대처 방법 🚚

  원하는 객체를 완성하기까지의 단계가 많고, 그 중간 단계에서 만들어진 객체들이 모두 버려진다면 성능 문제가 더욱 불거진다. 이 문제를 대처하는 2가지 방법에 대해서 알아보자.

📗 방법 1. 흔히 쓰일 '다단계 연산(multistep operation)들을 예측하여 기본 기능으로 제공하는 방법

  객체를 하나 완성하기 위해 Complex의 plus, minus, times, dividedBy를 사용한다고 하자. 이렇게 총 4개의 연산을 쓰는 게 아닌 'plusMinusTimesAndDividedBy'라는 메서드를 만들어서 하나의 연산을 사용하도록 할 수 있다.

기존에는 4개의 Complex 인스턴스를 만들었는데 위와 같은 방법을 사용하면 1개의 Complex 인스턴스만 만들면 된다.

📗 방법 2. package-private의 가변 동반 클래스를 제공하는 방법 (클라이언트들이 원하는 복잡한 연산들을 정확히 예측할 수 있는 경우)

public static void main(String[] args) {
    String name = "amenable";

    StringBuilder nameBuilder = new StringBuilder(name);
    nameBuilder.append("choi");
}

  String 자체는 불변 클래스이다. 하지만 String의 가변 동반 클래스인 StringBuilder를 이용하면 값을 변경할 수 있다.

 

 

이상으로 불변 클래스의 장점, 단점 그리고 단점 대처 방법에 대해서 알아보았다.

다음 글을 통해

• 변경 가능성을 최소화하라(불변 클래스를 만들 때 고려할 것)(3) - [4장. 클래스와 인터페이스(아이템17)]

대해서 알아보자.

 

해당 글은 백기선 님의 '이펙티브 자바 완벽 공략'을 참고하였습니다.