[Java] 쓰레드의 동기화

🔍 쓰레드의 동기화

멀티쓰레드 프로세스의 경우 같은 자원을 여러 쓰레드에서 공유하여 사용하기 때문에, 예상치 못한 결과를 얻을 수도 있다.

예를 들어 돈을 인출하는 과정을 두 개의 쓰레드 작업으로 생각해보자. 현재 3000원이 통장 잔고에 있고, 쓰레드 A는 3000원 인출을 요청한다. 이때, 쓰레드 B도 1000원을 인출 요청한다. 이 경우에 쓰레드 A가 deposit -= money 를 실행하기 전에 쓰레드 B가 deposit >= money 구문을 실행한다면 deposit이 마이너스가 될 것이다. 

public class BankAccount {
    private int deposit;
    public void withdraw(int money) {
    	if(deposit >= money) {
            deposit -= money;
            System.out.println(deposit);
        } else {
            System.out.println("돈을 인출할 수 없습니다.");
        }
    }
}

이러한 일을 막기 위해 한 쓰레드가 특정 작업을 끝마치기 전까지 다른 쓰레드의 작업 실행을 관리할 필요가 있다. 이를 위해 임계 영역(critical section)과 락(lock)이라는 개념이 도입되었다.

🗝️ 임계 영역과 락

공유 데이터를 사용하는 코드 영역을 임계 영역으로 지정하고, 공유 데이터가 가지고 있는 락을 획득한 쓰레드만 이 임계 영역에 진입할 수 있게 만듬으로써 위에서 발생한 문제를 해결할 수 있다. 이처럼 한 쓰레드가 진행 중인 작업에 다른 쓰레드가 접근하지 못하도록 막는 것을 '쓰레드 동기화(synchronization)'라고 한다.

 

🔍 자바의 쓰레드 동기화

🗝️ synchronized를 이용한 동기화

  자바에서 동기화를 가장 쉽게 달성할 수 있는 방법은 synchronized를 이용하는 것이다. synchronized는 임계 영역의 범위에 따라 성능에 크게 좌지우지 되기 때문에 최대한 적은 임계 영역을 설정하는 것이 중요하다. 

public class BankAccount {
    private int deposit;
    public synchronized void withdraw(int money) { // 메소드에 synchronized를 선언
    	if(deposit >= money) {
            deposit -= money;
            System.out.println(deposit);
        } else {
            System.out.println("돈을 인출할 수 없습니다.");
        }
    }
}

 

🗝️ wait()과 notify()

임계 영역은 락을 획득하지 못한 쓰레드는 접근할 수 없다. 따라서 락을 획득하여 작업을 실행하고 있는 쓰레드의 작업이 오래 걸린다면 다른 쓰레드는 모두 해당 락을 획득하기 위해 기다려야 한다. 이러한 상황을 개선하기 위해 wait()과 notify()를 사용할 수 있다. 

 

동기화된 임계 영역의 코드를 수행하다가 작업을 더 이상 진행할 수 없다면, wait()을 호출하여 쓰레드 A가 락을 반납하고 기다리게 만든다. 그러면 쓰레드 B가 락을 획득하여 작업을 수행할 수 있다. 나중에 작업을 진행할 수 있는 상황이 되면 notify()를 호출해서, 쓰레드 A가 다시 작업을 할 수 있도록 한다. 

void wait();                        // notify(), notifyAll()이 호출될 때 까지 기다린다.
void wait(long timeout);            // 지정된 시간동안 기다린다.
void wait(long timeout, int nanos);
void notify();
void notifyAll();

class Message {
    private String content;
    private boolean empty = true;
    
    public synchronized String read() {
        while (empty) {
            try {
                wait(); // 대기 상태로 전환
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        
        empty = true;
        notifyAll(); // 대기 중인 스레드를 깨움
        
        return content;
    }
    
    public synchronized void write(String message) {
        while (!empty) {
            try {
                wait(); // 대기 상태로 전환
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        
        empty = false;
        this.content = message;
        notifyAll(); // 대기 중인 스레드를 깨움
    }
}

public class WaitNotifyExample {
    public static void main(String[] args) {
        Message message = new Message();
        
        // 읽는 스레드
        Thread readerThread = new Thread(() -> {
            String receivedMessage = message.read();
            System.out.println("Received: " + receivedMessage);
        });
        
        // 쓰는 스레드
        Thread writerThread = new Thread(() -> {
            String messageToSend = "Hello World!";
            message.write(messageToSend);
            System.out.println("Sent: " + messageToSend);
        });
        
        // 스레드 실행
        readerThread.start();
        writerThread.start();
    }
}

만약 여기서 쓰는 스레드가 여러개라면 waiting pool에는 읽는 쓰레드와 쓰는 쓰레드가 같이 존재하게 된다. 여기서 notify()를 호출하게 JVM은 랜덤으로 하나의 쓰레드를 선택해서 실행한다. 만약 계속 읽는 쓰레드만 선택이 된다면 쓰는 쓰레드는 오랫동안 기다리게 될 수 있다. 이런 현상을 기아(starvation)이라고 한다.

 

이런 기아 현상을 막기 위해 notifyAll()을 호출할 수 있지만, 쓰는 쓰레드와 읽는 쓰레드 모두 통지를 받기 때문에 락을 얻기 위한 경쟁을 하게 된다. 이를 '경쟁 상태(race condition)'라고 한다. 이를 해결하기 위해서는 쓰는 쓰레드와 읽는 쓰레드를 구별해서 통지해야 한다. 이를 위해 Lock과 Condition을 이용할 수 있다.

 

🗝️ Lock과 Condition을 이용한 동기화

   java.util.concurrent.locks 패키지가 제공하는 lock 클래스들을 이용하면 synchronized를 사용했을 때 보다 더 유연한 동기화를 할 수 있다. 

[Lock Interface]

   쓰레드가 명시적으로 락을 획득하고 해제할 수 있는 메서드를 제공한다. 

// 락을 획득한다. 획득할 수 없는 경우 쓰레드는 블록된다.
void lock()

// 락을 해제한다. 예외가 발생해도 락이 해제될 수 있도록 finally 블록에서 호출되어야 한다. 
void unlock()

// 락 획득을 시도한다. 만약 다른 스레드에 의해 현재 락이 소유되고 있으면
// true를 반환하고 그렇지 않으면 false를 반환한다.
boolean tryLock()
boolean tryLock(long time, TimeUnit unit)

// 락과 함께 사용할 수 있는 Condition 객체를 반환한다. 
Condition newCondition()

 

[ReentrantLock]

    ReentratLock에는 두 개의 생성자가 있으며, 파라미터로 true를 넘기게 되면 오래 기다린 쓰레드가 lock을 획득 할 수 있게 한다. 하지만, 공정하게 처리하기 위해 어떤 쓰레드가 가장 오래 기다렸는지 확인하는 과정을 거치기 때문에 성능은 떨어진다.

ReentrantLock()
ReentrantLock(boolean fair)

public class SharedObject {
    //...
    ReentrantLock lock = new ReentrantLock();
    int counter = 0;

    public void perform() {
        lock.lock();
        try {
            // Critical section here
            count++;
        } finally {
            lock.unlock();
        }
    }
    //...
}

lock()은 lock을 얻을 때까지 쓰레드를 블락시키기 때문에 성능에 문제가 생길 수 있다. 따라서 응답성이 중요한 경우, tryLock()을 이용해서 지정시간 동안 lock을 얻지 못하면 다시 작업을 시도할 것인지 사용자가 결정하게 하는 것이 좋다. 

public void performTryLock(){
    //...
    boolean isLockAcquired = lock.tryLock(1, TimeUnit.SECONDS);
    
    if(isLockAcquired) {
        try {
            //Critical section here
        } finally {
            lock.unlock();
        }
    } else {
    	System.out.println("원하시면 다시 시도해주세요");
    }
}

 

[ReentrantReadWriteLock]

   읽기에는 공유적이고, 쓰기에는 배타적인 lock을 제공한다. 더 자세히 말하면 읽기 쓰레드가 임계 영역에 있는 경우 읽기 전용 쓰레드는 제한 없는 락을 얻게 된다. 하지만 쓰기를 하는 경우에는 쓰기 쓰레드 하나만 락을 가질 수 있다. 

public class ReadWriteMap<K, V> {
    private final Map<K, V> map = new HashMap<>();
    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    public void put(K key, V value) {
        lock.writeLock().lock();
        try {
            // 쓰기 작업 수행
            map.put(key, value);
        } finally {
            lock.writeLock().unlock();
        }
    }

    public V get(K key) {
        lock.readLock().lock();
        try {
            // 읽기 작업 수행
            return map.get(key);
        } finally {
            lock.readLock().unlock();
        }
    }
}

 

[StampedLock]

   lock을 걸거나 해지할 때 스탬프(long 타입의 정수값)를 사용하며, 읽기와 쓰기를 위한 잠금외에 낙관적 읽기 잠금(optimisitc reading lock)을 제공한다. 낙관적 읽기 잠금에서는 읽기 잠금이 걸려있을 때, 쓰기 잠금 요청이 들어오면 읽기 잠금을 기다리는 것이 아니라 읽기 잠금을 밀어낸다. 

public class StampedLockExample {
    private final StampedLock lock = new StampedLock();
    private double x;
    private double y;

    public void move(double deltaX, double deltaY) {
        long stamp = lock.writeLock();
        try {
            x += deltaX;
            y += deltaY;
        } finally {
            lock.unlockWrite(stamp);
        }
    }

    public double distanceFromOrigin() {
        long stamp = lock.tryOptimisticRead();
        double currentX = x;
        double currentY = y;
        if (!lock.validate(stamp)) {
            stamp = lock.readLock();
            try {
                currentX = x;
                currentY = y;
            } finally {
                lock.unlockRead(stamp);
            }
        }
        return Math.sqrt(currentX * currentX + currentY * currentY);
    }
}

move() 메서드는 쓰기 잠금을 획득하여 좌표를 수정하고, distanceFromOrigin() 메서드는 최적화된 읽기 잠금을 시도하여 좌표를 읽는다. validate()는 스탬프를 인수로 받으며, 해당 스탬프가 유용한지 확인한다. 유효성 검사는 데이터에 대한 쓰기 작업이 발생했는지 여부를 확인하여 수행된다. 만약 false를 반환하면 데이터에 대한 쓰기 작업이 발생한 것으로 다시 읽기 작업을 수행한다.

 

[Condition]

   Condition은 이미 생성된 lock으로부터 newCondition()을 호출해서 생성할 수 있으며 분리된 waiting pool을 사용할 수 있도록 도와준다. 

private ReentrantLock lock = new ReentrantLock();
private Condition readLock = lock.newCondition();
private Condition writeLock = lock.newCondition();

wait() & notify() 대신 Condition에서는 await() & signal()을 사용한다. 

public class ConditionExample {
    private final Lock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();
    private boolean conditionMet = false;

    public void doSomething() {
        lock.lock();
        try {
            while (!conditionMet) {
                condition.await();
            }
            // 조건이 충족됐을 때 수행할 작업
        } catch (InterruptedException e) {
            // 인터럽트 예외 처리
        } finally {
            lock.unlock();
        }
    }

    public void notifyCondition() {
        lock.lock();
        try {
            conditionMet = true;
            condition.signal();
        } finally {
            lock.unlock();
        }
    }
}