<aside> 🚨 충분하지 못한 동기화도 문제이지만 과도한 동기화도 문제다. 과도한 동기화는 성능을 떨어뜨리고, 교착상태에 빠뜨리고, 심지어 예측할 수 없는 동작을 낳기도 한다.

</aside>

1. 예측할 수 없는 동작을 낳는 과도한 동기화

<aside> 📚 응답 불가와 안전 실패를 피하려면 동기화 메서드/블록 안에서는 제어권을 클라이언트에게 양도하면 안된다.

</aside>

• 동기화된 영역 안에서는 재정의할 수 있는 메서드는 호출하면 안된다.
• 클라이언트가 넘겨준 함수 객체를 호출해도 안된다.
  • 이런 메서드들이 무슨 일을 할지 모르고, 통제할 수도 없기 때문
  • 이런 메서드가 하는 일에 따라 동기화된 영역은 예외를 일으키거나, 교착 상태에 빠지거나, 데이터를 훼손할 수도 있다.
• 이런 메서드를 외계인 메서드 라고 부른다.

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

		// 외계인 메서드 호출 부분
		// observer의 added : 동기화된 영역에서 재정의할 수 있는 메서드(제어권이 클라이언트에 있다)
    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;
    }

    @Override
    public boolean addAll(Collection<? extends E> c) {
        boolean result = false;
        for (E element : c) result |= add(element);
        return result;
    }
}

• 집합을 감싼 래퍼 클래스로, 집합에 원소가 추가되면 알림을 받을 수 있다. (관찰자 패턴)

public class Main {
    public static void main(String[] args) {

        ObservableSet<Integer> set = new ObservableSet<>(new HashSet<>());

        set.addObserver((s, e) -> System.out.println(e));

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

    }
}

• 위 코드는 0 부터 99 까지의 숫자를 출력한다.

set.addObserver(new SetObserver<Integer>() {
    public void added(ObservableSet<Integer> s, Integer e) {
        System.out.println(e);
        if (e == 23) set.removeObserver(this); // 문제 발생
    }
});

• 출력하는 값이 23 이면 자기 자신을 제거하는 관찰자를 추가했다.
• 그러나 실제로 실행해보면 23까지 출력한 다음 ConcurrentModificationException 을 던진다.
• 관찰자의 added 메서드 호출이 일어난 시점이 notifyElementAdded 가 관찰자들의 리스트를 순회하는 도중이기 때문이다.
  • added 메서드 : ObservableSet의 removeObserver 메서드 호출
  • removeObserver 메서드 : observers.remove 메서드 호출
    • 리스트에서 원소를 제거하려 하는데, 마침 그 리스트를 순회하는 도중이다 (공유자원 침범)
    • notifyElementAdded 메서드에서 수행하는 순회는 동기화 블록 안에 있어서 동시 수정이 일어나지 않음을 보장하지만, 정작 자신이 콜백을 거쳐 되돌아와 수정하는 것까지 막지는 못한다.

2. 교착 상태에 빠트리는 과도한 동기화

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.sumbit(() -> s.removeObserver(this)).get();
            } catch (ExecutionException | InterruptedException ex) {
                throw new AssertionError(ex);
            } finally {
                exec.shtdown();
            }
            s.removeObserver(this);
        }
    }
});

• removeObserver 를 직접 호출하지 않고, 실행자 서비스를 사용해 다른 스레드에 구독 해지를 부탁해보자