[Effective Java] 아이템 79. 과도한 동기화는 피하라.

🎯 아이템 79. 과도한 동기화는 피하라.

응답 불가와 안전 실패를 피하려면 동기화 메서드나 동기화 블록 안에서는 제어를 절대로 클라이언트에 양도하면 안된다. 동기화된 영역을 포함한 클래스 관점에서는 이런 메서드는 모두 바깥 세상에서 온 외계인이므로 예측할 수 없는 이슈를 발생 시킨다

• 잘못된 코드. 동기화 블록 안에서 외계인 메서드를 호출한다.

public class ObservableSet<E> extends ForwardingSet<E> {
    public ObservableSet(Set<E> set) { super(set); }

    private final List<SetObserver<E>> observers = new ArrayList<>();

    public void addObserver(SetObserver<E> observer) {
        synchronized(observers) {
            observers.add(observer);
        }
    }

    public boolean removeObserver(SetObserver<E> observer) {
        synchronized(observers) {
            return observers.remove(observer);
        }
    }

    private void notifyElementAdded(E element) {
        synchronized(observers) {
            for (SetObserver<E> observer : observers)
                observer.added(this, element);
        }
    }

    @Override 
    public boolean add(E element) {
        boolean added = super.add(element);
        if (added)
            notifyElementAdded(element);
        return added;
    }
}

public static void main(String[] args) {
    ObservableSet<Integer> set = new ObservableSet<>(new HashSet<>());

    set.addObserver(new SetObserver<>() {
        public void added(ObservableSet<Integer> s, Integer e) {
            System.out.println(e);
            if (e == 23) // 값이 23이면 자신을 구독해지한다.
                s.removeObserver(this);
        }
    });

    for (int i = 0; i < 100; i++)
        set.add(i);
}

이 프로그램은 23까지 출력한 다음 ConcurrentModificationException을 던진다. added 메서드 호출이 일어난 시점이 notifyElementAdded가 관찰자들의 리스트를 순회하는 도중이기 때문이다.

• 쓸데없이 백그라운드 스레드를 사용하는 관찰자

public static void main(String[] args) {
    ObservableSet<Integer> set = new ObservableSet<>(new HashSet<>());

    set.addObserver(new SetObserver<>() {
        public void added(ObservableSet<Integer> s, Integer e) {
            System.out.println(e);
            if (e == 23) {
                ExecutorService exec = Executors.newSingleThreadExecutor();
                try {
                    exec.submit(() -> s.removeObserver(this)).get();
                } catch (ExecutionException | InterruptedException ex) {
                    throw new AssertionError(ex);
                } finally {
                    exec.shutdown();
                }
            }
        }
    });

    for (int i = 0; i < 100; i++)
        set.add(i);
}

이 프로그램을 실행하면 예외는 나지 않지만 교착상태에 빠진다.

• 해결책 1 외계인 메서드 호출을 동기화 블록 바깥으로 옮긴다.

private void notifyElementAdded(E element) {
    List<SetObserver<E>> snapshot = null;
    synchronized(observers) {
        snapshot = new ArrayList<>(observers);
    }
    for (SetObserver<E> observer : snapshot)
        observer.added(this, element);
}

• 해결책 2 CopyOnWriteArrayList를 사용해 구현한 스레드 안전하고 관찰 가능한 집합

private final List<SetObserver<E>> observers = new CopyOnWriteArrayList<>();

기본 규칙은 동기화 영역에서는 가능한 한 일을 적게 하는 것이다.

• 가변 클래스를 작성하려거든 다음 두 선택지 중 하나를 따르자.

1.동기화를 하지말고, 클래스를 동시에 사용해야 하는 클래스가 외부에서 동기화도록 하자.

2.동기화를 내부에서 수행해 스레드 안전한 클래스로 만들자.

1️⃣ 락 분할(lock splitting)

2️⃣ 락 스트라이이핑(lock striping)

3️⃣ 비차단 동시성 제어(nonblocking concurrency control)

참고 자료

Joshua Bloch, 『Effective Java 3/E』, 개앞맵시 옮김, 프로그래밍인사이트(2018)
http://www.kyobobook.co.kr/product/detailViewKor.laf?ejkGb=KOR&mallGb=KOR&barcode=9788966262281&orderClick=LEa&Kc=