@ThreadSafe
public final class Counter {

    @GuardedBy("this") private long value = 0;

    public synchronized long getValue() {
        return value;
    }

    public synchronized long increment() {
        if (value == Long.MAX_VALUE)
            throw new IllegalStateException("counter overflow");
        return ++value;
    }
}

// 잘못된 예: 연관된 변수를 별도 락으로 보호
synchronized(lockA) { lower = newLower; }
// 이 사이에 다른 스레드가 개입 가능!
synchronized(lockB) { upper = newUpper; }

// 올바른 예: 같은 락으로 한번에 변경
synchronized(this) {
    lower = newLower;
    upper = newUpper;
}

// 블로킹 큐 — 선행 조건이 만족될 때까지 대기
BlockingQueue<String> queue = new LinkedBlockingQueue<>();

// 생산자 스레드
queue.put("data");   // 큐가 꽉 차면 대기

// 소비자 스레드
String data = queue.take();  // 큐가 비면 대기

@ThreadSafe
public class PersonSet {

    @GuardedBy("this")
    private final Set<Person> mySet = new HashSet<>();

    public synchronized void addPerson(Person p) {
        mySet.add(p);
    }

    public synchronized boolean containsPerson(Person p) {
        return mySet.contains(p);
    }
}

// ArrayList는 스레드 안전하지 않음
List<String> list = new ArrayList<>();

// synchronized 래퍼로 감싸기
List<String> safeList = Collections.synchronizedList(list);

// 이후 원본 list를 직접 사용하면 안 됨!
// 반드시 safeList를 통해서만 접근해야 함

// 자바 모니터 패턴의 전형적인 구조
public class MonitorExample {

    @GuardedBy("this")
    private int state;

    public synchronized int getState() {
        return state;
    }

    public synchronized void setState(int newState) {
        this.state = newState;
    }
}

public class PrivateLock {

    private final Object myLock = new Object();
    private Widget widget;

    void someMethod() {
        synchronized (myLock) {
            // widget 변수의 값을 읽거나 변경
        }
    }
}

@ThreadSafe
public class MonitorVehicleTracker {

    @GuardedBy("this")
    private final Map<String, MutablePoint> locations;

    public MonitorVehicleTracker(Map<String, MutablePoint> locations) {
        this.locations = deepCopy(locations);
    }

    public synchronized Map<String, MutablePoint> getLocations() {
        return deepCopy(locations);  // 복사본 반환
    }

    public synchronized MutablePoint getLocation(String id) {
        MutablePoint loc = locations.get(id);
        return loc == null ? null : new MutablePoint(loc);
    }

    public synchronized void setLocation(String id, int x, int y) {
        MutablePoint loc = locations.get(id);
        if (loc == null)
            throw new IllegalArgumentException("No such ID: " + id);
        loc.x = x;
        loc.y = y;
    }

    private static Map<String, MutablePoint> deepCopy(
            Map<String, MutablePoint> m) {
        Map<String, MutablePoint> result = new HashMap<>();
        for (String id : m.keySet())
            result.put(id, new MutablePoint(m.get(id)));
        return Collections.unmodifiableMap(result);
    }
}

@Immutable
public class Point {
    public final int x, y;

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

@ThreadSafe
public class DelegatingVehicleTracker {

    private final ConcurrentMap<String, Point> locations;

    public DelegatingVehicleTracker(Map<String, Point> points) {
        locations = new ConcurrentHashMap<>(points);
    }

    // 실시간 뷰 반환 (복사 비용 없음)
    public Map<String, Point> getLocations() {
        return Collections.unmodifiableMap(locations);
    }

    public Point getLocation(String id) {
        return locations.get(id);
    }

    public void setLocation(String id, int x, int y) {
        if (locations.replace(id, new Point(x, y)) == null)
            throw new IllegalArgumentException("No such ID: " + id);
    }
}

// 위임 가능한 예: 독립적인 두 변수
public class IndependentState {
    // keyListeners와 mouseListeners는 서로 독립적
    private final CopyOnWriteArrayList<KeyListener> keyListeners
        = new CopyOnWriteArrayList<>();
    private final CopyOnWriteArrayList<MouseListener> mouseListeners
        = new CopyOnWriteArrayList<>();

    public void addKeyListener(KeyListener listener) {
        keyListeners.add(listener);
    }

    public void addMouseListener(MouseListener listener) {
        mouseListeners.add(listener);
    }
}

// 위임 불가능한 예: 의존 관계가 있는 두 변수
public class NumberRange {
    // lower <= upper 제약 조건이 있다
    private final AtomicInteger lower = new AtomicInteger(0);
    private final AtomicInteger upper = new AtomicInteger(0);

    // 이 메서드는 스레드 안전하지 않다!
    // lower와 upper를 개별적으로 검사하므로
    // 그 사이에 다른 스레드가 값을 변경할 수 있다
    public void setLower(int i) {
        if (i > upper.get())     // check
            throw new IllegalArgumentException();
        lower.set(i);            // act → check-then-act 경쟁 조건!
    }
}

// 상속으로 "없으면 추가" 구현 — 위험한 방법
public class BetterVector<E> extends Vector<E> {

    public synchronized boolean putIfAbsent(E x) {
        boolean absent = !contains(x);
        if (absent)
            add(x);
        return absent;
    }
}

// 잘못된 클라이언트 측 락 — this를 잠그지만 list는 다른 락 사용
public class ListHelper<E> {
    public List<E> list = Collections.synchronizedList(new ArrayList<>());

    // 이 메서드는 스레드 안전하지 않다!
    public synchronized boolean putIfAbsent(E x) {
        boolean absent = !list.contains(x);
        if (absent)
            list.add(x);
        return absent;
    }
    // ListHelper의 락(this)과 list의 락이 다르다!
}

// 올바른 클라이언트 측 락 — list와 같은 락 사용
public class ListHelper<E> {
    public List<E> list = Collections.synchronizedList(new ArrayList<>());

    public boolean putIfAbsent(E x) {
        synchronized (list) {  // list 객체를 락으로 사용
            boolean absent = !list.contains(x);
            if (absent)
                list.add(x);
            return absent;
        }
    }
}

@ThreadSafe
public class ImprovedList<E> implements List<E> {

    private final List<E> list;

    public ImprovedList(List<E> list) {
        this.list = list;
    }

    public synchronized boolean putIfAbsent(E x) {
        boolean absent = !list.contains(x);
        if (absent)
            list.add(x);
        return absent;
    }

    // List 인터페이스의 나머지 메서드도
    // synchronized로 위임
    public synchronized boolean add(E e) {
        return list.add(e);
    }

    public synchronized E get(int index) {
        return list.get(index);
    }

    // ... 나머지 메서드 생략
}

@ThreadSafe                    // 클래스가 스레드 안전함
public class SafeCounter {

    @GuardedBy("this")         // this 락으로 보호됨
    private long count = 0;

    public synchronized long getCount() {
        return count;
    }

    public synchronized void increment() {
        count++;
    }
}