아이템 17. 변경 가능성을 최소화 하라.

핵심 정리 1: 불변 클래스

불변 클래스는 가변 클래스보다 설계, 구현 및 사용이 쉬우며 오류가 생길 여지도 적고 훨씬 안전하다.
- 특히나 사용하기 안전하기 때문에 멀티 스레드 환경에서 이점이 크다.
  - 불변이기 때문에 여러 스레드에서 한번만 읽고 캐싱해서 사용해도 되는 등...
불변 클래스를 만드는 다섯 가지 규칙
1. 객체의 상태를 변경하는 메서드를 제공하지 않는다.
2. 클래스를 확장할 수 없도록 한다.
3. 모든 필드를 final로 선언한다. (JLS 17.5)
4. 모든 필드를 private으로 선언한다. (아이템 15, 16)
5. 자신 외에는 내부의 가변 컴포넌트에 접근할 수 없도록 한다.
  - 예시 참고

예시

예시에 활용될 PhoneNumber 클래스

@Getter @Setter
public class PhoneNumber {

    private short areaCode;

    private short prefix;

    private short lineNum;

}

객체의 상태를 변경하는 메서드를 제외

@Getter
public class PhoneNumber {

    public PhoneNumber(short areaCode, short prefix, short lineNum) {
        this.areaCode = areaCode;
        this.prefix = prefix;
        this.lineNum = lineNum;
    }

    private short areaCode;

    private short prefix;

    private short lineNum;

}

MyPhoneNumber는 PhoneNumber 타입으로 사용한다면 불변이 아니게 된다.


public class MyPhoneNumber extends PhoneNumber {

    public MyPhoneNumber(short areaCode, short prefix, short lineNum) {
        super(areaCode, prefix, lineNum);
    }

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

클래스에 final 키워드로 상속 금지

모든 필드에 final 키워드로 필드 변경을 방지

public final class PhoneNumber {

    private final short areaCode, prefix, lineNum;

    public PhoneNumber(short areaCode, short prefix, short lineNum) {
        this.areaCode = areaCode;
        this.prefix = prefix;
        this.lineNum = lineNum;
    }

    public short getAreaCode() {
        return areaCode;
    }

    public short getPrefix() {
        return prefix;
    }

    public short getLineNum() {
        return lineNum;
    }

    // 내부에서 사용 중 필드 값이 언제 변경될지 모르기 때문이다.
//    public short doSomething() {
//        return areaCode + 1;
//    }
}

"자신 외에는 내부의 가변 컴포넌트에 접근할 수 없도록 한다."

불변 클래스인 Person 안에 가변 클래스가 필드로 존재.
- Address의 reference가 final인 의미
- Address가 가진 정보들까지 final은 아니다.

public class Address {

    private String zipCode;

    private String street;

    private String city;

}

public final class Person {

    private final Address address;

    public Person(Address address) {
        this.address = address;
    }

    // 이와 같은 방법은 가변적인 컴포넌트를 제공하기에 불변 클래스로서 옳지 않은 방법이다.
//    public Address getAddress() {
//        return address;
//    }

    // 방어적인 복사 방법으로 전달하는 방법
    public Address getAddress() {
        Address copyOfAddress = new Address();
        copyOfAddress.setStreet(address.getStreet());
        copyOfAddress.setZipCode(address.getZipCode());
        copyOfAddress.setCity(address.getCity());
        return copyOfAddress;
    }

    public static void main(String[] args) {
        Address seattle = new Address();
        seattle.setCity("Seattle");

        Person person = new Person(seattle);

        Address redmond = person.getAddress();
        redmond.setCity("Redmond");

        // Seattle
        System.out.println(person.address.getCity());
    }
}

핵심 정리 2: 불변 클래스의 장점과 단점

함수형 프로그래밍에 적합하다.
- 피연산자에 함수를 적용한 결과를 반환하지만 피연산자가 바뀌지는 않는다.
불변 객체는 단순하다.
불변 객체는 근본적으로 스레드 안전하여 따로 동기화할 필요가 없다.
불변 객체는 안심하고 공유할 수 있다.
- 상수로 취급할 수 있다.
- public static final
불변 객체끼리는 내부 데이터를 공유할 수 있다.
- BigInteger 클래스
  - 내부 : 부호 - int , 크기 - int[]
  - negate를 쓰면 부호를 반대로 변경해준다.
객체를 만들 때 불변 객체로 구성하면 이점이 많다.
실패 원자성을 제공한다. (아이템 76, p407)
- 근본적으로 실패 원자성을 제공한다.
- 가변 클래스의 경우라면, operation을 하기 전에 값을 검증하므로써 실패 원자성을 제공할 수 있다.
단점 : 값이 다르면 반드시 별도의 객체로 만들어야 한다.
- 다단계 연산을 제공하거나, 가변 동반 클래스를 제공하여 대처할 수 있다.
- 다단계 연산 : 여러 연산을 하나로 묶는다.
  - 예) plus(), minus(), times()를 사용해야하는 경우, 이 셋을 묶어 연산을 한번에 하면 객체도 하나만 만들어주면 된다.
- 가변 동반 클래스 : 본인의 값을 처리하기 편리하게 해주는 클래스이다.
  - 예) String, StringBuilder

// 코드 17-1 불변 복소수 클래스 (106-107쪽)
public final class Complex {
    private final double re;
    private final double im;

    public static final Complex ZERO = new Complex(0, 0);
    public static final Complex ONE  = new Complex(1, 0);
    public static final Complex I    = new Complex(0, 1);

    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);
    }

    // 코드 17-2 정적 팩터리(private 생성자와 함께 사용해야 한다.) (110-111쪽)
    public static Complex valueOf(double re, double im) {
        return new Complex(re, 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;

        // == 대신 compare를 사용하는 이유는 63쪽을 확인하라.
        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)";
    }
}

불변 객체끼리는 내부 데이터를 공유할 수 있다.

내부의 this.mag가 변경되면, 추후 다시 negate()를 호출하면 값이 변경될텐데?
- BigInteger는 불변 객체이다.
- 변경될 일이 없다.

public class BigIntExample {

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

        // Point 가 불변이라서 가능한 케이스이다.
        // 이런 이점이 있기에 불변 객체들이 많을 수록 이점이 많아진다.
        final Set<Point> points = new HashSet<>();
        Point firstPoint = new Point(1, 2);
        points.add(firstPoint);

    }
}

핵심 정리 3: 불변 클래스를 만들 때 고려할 것

상속을 막을 수 있는 또 다른 방법
- private 또는 package-private 생성자 + 정적 팩터리
  - private : 내부 클래스에서 상속을 부분적 허용
  - package-private : 동일 패키지 내에서 상속을 부분적 허용
  - 정적 팩터리 : 인스턴스 사용을 위해 외부에서 접근하는 방법
- 확장이 가능하다. 다수의 package-private 구현 클래스를 만들 수 있다.
- 정적 팩터리를 통해 여러 구현 클래스 중 하나의 활용할 수 있는 유연성을 제공하고 객체 캐싱 기능으로 성능을 향상 시킬 수도 있다.
재정의가 가능한 클래스는 방어적인 복사를 사용해야 한다.
모든 "외부에 공개하는" 필드가 final이어야 한다.
- 계산 비용이 큰 값은 해당 값이 필요로 할 때 (나중에) 계산하여 final이 아닌 필드에 캐시해서 쓸 수도 있다.

정적 팩터리 사용

장점
- 내부에서 다른 구현체를 사용해도 된다.
- 인스턴스를 캐싱해둘 수도 있는 선택지가 생긴다.

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

    public static final Complex ZERO = new Complex(0, 0);
    public static final Complex ONE  = new Complex(1, 0);
    public static final Complex I    = new Complex(0, 1);

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

    private static class MyComplex extends Complex {

        private MyComplex(double re, double im) {
            super(re, im);
        }
    }

    // 코드 17-2 정적 팩터리(private 생성자와 함께 사용해야 한다.) (110-111쪽)
    public static Complex valueOf(double re, double im) {
        return new MyComplex(re, im);
    }

...
}

public class ComplexExample {

    // 외부에서 정적 팩터리를 통해 인스턴스를 만들면 MyComplex가 아닌 Complex
    public static void main(String[] args) {
        Complex complex = Complex.valueOf(1, 0.222);
    }
}

상속이 허용된 불변 클래스라면

불변 클래스의 하위 클래스들이 어떻게 구성되어 있을지 확실하지 않기 때문에,
아래와 같이 방어적으로 사용할 수 있다.

public class BigIntegerUtils {

    public static BigInteger safeInstance(BigInteger val) {
        return val.getClass() == BigInteger.class ? val : new BigInteger(val.toByteArray());
    }
}

모든 "외부에 공개하는" 필드가 final이어야 한다.

모든 필드가 final이어야 할 필요는 없다는 의미이다.
- final은 만들어질 때부터 값이 정해져야한다.
- hashCode()가 호출될 때 hashCode가 생성되는 lazyLoading
  - 필요할 때 계산하고 싶은 경우
    - 연산의 비용이 높은 경우
  - 한번 계산 후에는 넣어두고 계속 활용
    - 값이 변경하지 않을 예정

public final class PhoneNumber {

...

    // 해시코드를 지연 초기화하는 hashCode 메서드 - 스레드 안정성까지 고려해야 한다. (71쪽)
    private volatile int hashCode; // 자동으로 0으로 초기화된다.

    @Override public int hashCode() {
        if (this.hashCode != 0) {
            return hashCode;
        }

        synchronized (this) {
            int result = hashCode;
            if (result == 0) {
                result = Short.hashCode(areaCode);
                result = 31 * result + Short.hashCode(prefix);
                result = 31 * result + Short.hashCode(lineNum);
                this.hashCode = result;
            }
            return result;
        }
    }

}

완벽 공략

모든 클래스를 "불변" 으로 만들 수 없다. 불변으로 만들 수 없을 때, 변경 가능성을 최소화해야 한다.
p105, 새로 생성된 불변 인스턴스를 동기화 없이 다른 스레드로 건네도 문제없이 동작 (JLS 17.5)
p106, readObject 메서드 (아이템 88)에서 방어적 복사를 수행하라.
p112, 불변 클래스의 내부에 가변 객체를 참조하는 필드가 있다면... (아이템 88)
- Serializable 과 관련이 있음
p113, java.util.concurrnet 패키지의 CountDownLatch 클래스

완벽 공략 32. final과 자바 메모리 모델(JMM)

final을 사용하면 안전하게 초기화 할 수 있다. "안전하다" 란?

JMM과 final을 완벽히 이해하려면 JLS 17.4와 JLS 17.5를 참고하세요.
JMM:
- 자바 메모리 모델은 JVM의 메모리 구조가 아니다
- 적법한 (legal) 프로그램 실행 규칙
- 메모리 모델이 허용하는 범위내에서 프로그램을 어떻게 실행하든 구현체(JVM) 의 자유 (이 과정에서 실행 순서가 바뀔 수도 있다)
어떤 인스턴스의 final 변수를 초기화 하기 전까지 해당 인스턴스를 참조하는 모든 쓰레스는 기다려야 한다. (freeze)

JMM 스펙상 가변 클래스의 불완전한 초기화 예시

public class Whiteship {
    private int x;
    private int y;
    public Whiteship() {
        this.x = 1;
        this.y = 2;
    }
    public static void main(String[] args) {
        Whiteship whiteship = new Whiteship();

        /* 실행 순서는 메모리 모델만 준수한다면 변경될 수 있다
         * 단, 한 스레드 내에서 유효한지만 확인한다
         * 따라서 멀티스레드 환경에서는 불완전한 초기화가 발생할 수 있다
         *
         * Object w = new Whiteship()
         * whiteship = w
         * w.x = 1
         * w.y = 2
         *
         * or
         * Object w = new Whiteship()
         * w.x = 1
         * w.y = 2
         * whiteship = w
         * */
    }
}

요약

특정 인스턴스가 초기화 될 때 특정 필드가 반드시 값을 갖도록 보장하고 싶다면 final 키워드를 사용해야 한다.
final 키워드를 사용하지 않으면 멀티 스레드 환경에서 초기화 되지 않은 상태에서 참조될 가능성이 있다

완벽 공략 33. java.util.concurrnet 패키지

병행(concurrency) 프로그래밍에 유용하게 사용할 수 있는 유틸리티 묶음

병행(Concurrency) vs 병렬(Parallelism)

병행은 여러 작업을 번갈아 가며 실행해 마치 동시에 여러 작업을 동시에 처리하듯 보이지만, 실제 로는 한번에 오직 한 작업만 실행한다. CPU가 한개여도 가능하다. (그림1)
병렬은 여러 작업을 동시에 처리한다. CPU가 여러개 있어야 가능하다. (그림2)
자바에서는 이 두 개념을 모두 사용(병행이자 병렬로)하여 스레드를 동작시킨다 (그림3)
자바의 concurrent 패키지는 병행 애플리케이션에 유용한 다양한 툴을 제공한다.
- BlockingQueue, Callable, ConcurrrentMap, Executor, ExecutorService, Future, ...

완벽 공략 33. CountDownLatch

다른 여러 스레드로 실행하는 여러 오퍼레이션이 마칠 때까지 기다릴 때 사용할 수 있는 유틸리티

초기화 할 때 숫자를 입력하고, await() 메서드를 사용해서 숫자가 0이 될때까지 기다린다.
숫자를 셀 때는 countDown() 메서드를 사용한다.
재사용할 수 있는 인스턴스가 아니다. 숫자를 리셋해서 재사용하려 CyclicBarrier를 사용해야 한다.
시작 또는 종료 신호로 사용할 수 있다.
멀티 스레드 환경에서 여러 스레드들을 특정 조건에 맞춰 기다렸다가 실행하거나 하는 상황 등에 사용

CountDownLatch 예시

public class ConcurrentExample {
    public static void main(String[] args) throws InterruptedException {
        int N = 10;
        CountDownLatch startSignal = new CountDownLatch(1);
        CountDownLatch doneSignal = new CountDownLatch(N);

        for (int i = 0; i < N; ++i) // create and start threads
            new Thread(new Worker(startSignal, doneSignal)).start();

        ready();                        // don't let run yet
        startSignal.countDown();      // let all threads proceed
        doneSignal.await();           // wait for all to finish
        done();
    }

    private static void ready() {
        System.out.println("준비~~~");
    }

    private static void done() {
        System.out.println("끝!");
    }

    private static class Worker implements Runnable {

        private final CountDownLatch startSignal;
        private final CountDownLatch doneSignal;

        public Worker(CountDownLatch startSignal, CountDownLatch doneSignal) {
            this.startSignal = startSignal;
            this.doneSignal = doneSignal;
        }

        public void run() {
            try {
                startSignal.await();
                doWork();
                doneSignal.countDown();
            } catch (InterruptedException ex) {
            } // return;
        }

        void doWork() {
            System.out.println("working thread: " + Thread.currentThread().getName());
        }
    }
}

tonykang22 / study

[이펙티브 자바] 아이템 17. 변경 가능성을 최소화 하라. #128

아이템 17. 변경 가능성을 최소화 하라.

핵심 정리 1: 불변 클래스

예시

예시에 활용될 PhoneNumber 클래스

객체의 상태를 변경하는 메서드를 제외

MyPhoneNumber는 PhoneNumber 타입으로 사용한다면 불변이 아니게 된다.

클래스에 final 키워드로 상속 금지

모든 필드에 final 키워드로 필드 변경을 방지

"자신 외에는 내부의 가변 컴포넌트에 접근할 수 없도록 한다."

핵심 정리 2: 불변 클래스의 장점과 단점

불변 객체끼리는 내부 데이터를 공유할 수 있다.

핵심 정리 3: 불변 클래스를 만들 때 고려할 것

정적 팩터리 사용

상속이 허용된 불변 클래스라면

모든 "외부에 공개하는" 필드가 final이어야 한다.

완벽 공략

완벽 공략 32. final과 자바 메모리 모델(JMM)

JMM 스펙상 가변 클래스의 불완전한 초기화 예시

요약

완벽 공략 33. java.util.concurrnet 패키지

병행(Concurrency) vs 병렬(Parallelism)

완벽 공략 33. CountDownLatch

CountDownLatch 예시