[Java] 멀티스레드와 동기화에 대해서

 

공유자원과 임계영역

 

🔲 공유 자원 : 여러 스레드가 동시에 접근할 수 있는 자원

 

🔲 임계 영역 : 공유자원들 중 여러 스레드가 동시에 접근했을 때, 문제가 생길만한 부분

 

 

 

🔶경쟁 상태?

 

둘 이상의 스레드가 공유자원을 병행적으로 읽거나 쓸때, 타이밍이나 접근 순서에 따라 실행 순서가 달라지는 상황(race 현상)

 

 

 

 

 

🔶Read - Modify - Write

 

@RestController
@RequestMapping("/race-condition")
public class RaceConditionCotroller {
    public static Integer studentCount = 0;
    
    @PostMapping("/1/increase")
    public ResponseEntity<Void> increaseCount() {
        studentCount++;
        return ResponseEntity.ok().build();
    }
    
    @GetMapping("/1/count")
    public ResponseEntity<Integer> getCount() {
        return ResponseEntity.ok(studentCount);
    }
    
}

 

 

만약 여기서 30개의 요청이 들어와 increase 연산을 수행한다고 해보자. 예상할 수 있는 결과로 studentCount는 30이 될 것이다. 하지만, 실제 동작은 그러지 않을 수 있다.

 

 

 

이는 studentCount++ 라는 코드에서 Thread간의 race 때문에 발생하기 때문이다. studentCount는 그 내부적으로 변수의 값을 읽고(Read), 수정하고(Modify), 덮어씌우는(Write)의 과정을 거친다.

 

 

 

헌데, 다른 쓰레드에서 이러한 세 과정에서 순서가 잘못 겹친다면, 덮여씌워질 때 하나를 더하는 과정이 무시될 수 있다.

 

 

 

🔶Check - then - act

 

@PostMapping("/2/check-then-act")
public ResponseEntity<Void> printWarning() throws InterruptedException {
    studentCount++;
    if (studentCount < 30) {
        Thread.sleep(1);
        System.out.println("폐강위험! studentCount = " + studentCount);
    }
    return ResponseEntity.ok().build();
}

 

 

위 예시는 수강 신청 후에, 수를 세서 30명 미만이면 폐강 위험이라는 출력문을 표시한다. 하지만 그 결과 출력문에는 예상과 다른 엉뚱한 숫자가 온 것을 확인할 수 있다.

 

 

이 이유 또한 Thread간의 race 때문이다. 예를 들어, Thread1에서 studentCount가 하나 증가하고, if문을 통과했다고 하자. 그러면, Thread2에서 하나를 증가시켜 30보다 커지더라도 Thread1에서의 if문 로직은 그대로 작동하게 되는 것이다.

 

 

 

 

 

 

원자성

 

🔲 원자성 : 공유 자원에 대한 작업의 단위가 더이상 쪼개질 수 없는 하나의 연산인 것처럼 동작하는 것이다.

 

 

위와 같은 경쟁 조건을 발생시키지 않게 하기 위해 원자성을 보장하여야 한다.

 

 

 

 

가시성

 

 

public class Main {

    public static boolean missileLaunched = false;

    public static class MissileIntercepter extends Thread {
        @Override
        public void run() {
            while(!missileLaunched) { /* 대기 */ }
            System.out.println("요격!");
        }
    }

    public static void main(String[] args) throws InterruptedException{
        final MissileIntercepter missileIntercepter = new MissileIntercepter();
        missileIntercepter.start();
        Thread.sleep(5000);
        launchMissile();
        missileIntercepter.join();

    }

    private static void launchMissile() { missileLaunched = true; }
}

 

 

Thread 상에서 변수의 값이 바뀔 때까지 wait하는 코드 예제이다. 하지만, 예상과 다르게 while문을 빠져나가지 못해, 출력을 하지 못하고 무한 루프에 빠지게 된다.

 

 

 

 

 

 

 

 

Thread에서 가지는 변수 값들은 결국 Main Memory에서 가져온다. 하지만, 이 Main Memory의 값을 1:1로 바로 반영되는 것이 아니라 각 Thread마다 CPU Cache안에 값이 저장된다.

 

 

 

그래서 중간에 Main Thread에서 missile 변수의 값이 변하여 Main Memory 상에 반영되어도, Thread1 상에서는 반영되지 않기 때문에 무한 루프가 발생하는 것이다.

 

 

 

이렇게, Main Memory 상에 있는 진짜 값을 보는 것을 "가시성" 이라고 한다.

 

 

 

가시성을 보장하기 위해서 자바에서는 volatile이라는것을 제공한다. 즉, Main Memory 상의 진짜 변수 값을 볼 수 있도록 한다.

 

 

 

public class Main {

    public volatile static boolean missileLaunched = false;

    public static class MissileIntercepter extends Thread {
        @Override
        public void run() {
            while(!missileLaunched) { /* 대기 */ }
            System.out.println("요격!");
        }
    }

    public static void main(String[] args) throws InterruptedException{
        final MissileIntercepter missileIntercepter = new MissileIntercepter();
        missileIntercepter.start();
        Thread.sleep(5000);
        launchMissile();
        missileIntercepter.join();

    }

    private static void launchMissile() { missileLaunched = true; }
}

 

 

 

 

동기화

 

 

🔲 동기화란?

 

원자성과 가시성을 보장하기 위한 것이자, 특정 스레드가 작업을 수행하는 동안 다른 작업은 진행하지 않고 대기하는 방식을 말한다.

 

 

 

 

 

블로킹과 모니터

 

 

🔲 모니터란?

 

자바에서 동기화를 위한 도구이다.

 

✅ 배타 동기는 synchronized

 

✅ 조건 동기는 wait(), notify(), notifyAll()이다.

 

 

 

임계 영역에는 하나의 쓰레드만이 Lock을 가지고 들어갈 수 있다.

 

만약 임계 영역안의 쓰레드가 wait() 함수를 통해 sleep한다면, 조건동기 큐로 들어가게 된다.

 

그러면, 임계 영역이 비게되고, 배타동기큐에 쌓여있던 쓰레드가 임계 영역안으로 이동한다.

 

 

 

만약 이 상태에서 notify()를 호출한다면, 조건동기 큐에서 잠들어 있던 쓰레드가 깨어나 다음 임계 영역이 빈 순간 임계 영역으로 들어간다.

 

 

 

 

자바에서 내부적으로 이러한 동작이 가능하도록 하려면(즉, 블로킹이 가능하게 하려면) Synchronized 키워드를 사용하면 된다. 아래는 위의 원자성이 보장 안된 코드를 수정한 것이다.

 

 

 

 

@PostMapping("/2/check-then-act")
public synchronized ResponseEntity<Void> printWarning() throws InterruptedException {
    studentCount++;
    if (studentCount < 30) {
        Thread.sleep(1);
        System.out.println("폐강위험! studentCount = " + studentCount);
    }
    return ResponseEntity.ok().build();
}

 

 

 

 

 

 

 

synchronized의 동작방식

 

 

임계 구역 안에는 하나의 쓰레드만이 들어갈 수 있고, 결론적으로는 동기적으로 쓰레드가 동작하여 이전과 같은 race 문제가 발생하지 않고, 가시성 또한 보장된다.

 

 

 

 

 

 

 

 

물론 synchronized를 붙인다고 무적이 되는 것은 아니다.

 

하나의 임계 구역안에서만 쓰레드가 동작하기 때문에 나머지 쓰레드들은 대기해야 하는 성능 저하 문제가 발생할 수 있다.

 

 

 

 

 

 

 

 

블로킹 - 데드락(교착상태)

 

 

 

데드락은 두 개의 쓰레드가 서로가 가지고 있는 락이 해제되기를 기다리는 상태를 말한다.

 

즉, 데드락이 발생한 동안에는 아무런 작업을 하지 못하고 무한정 대기해야만 한다.

 

 

public class Main {

    public static Object object1 = new Object();
    public static Object object2 = new Object();

    public static void main(String[] args) {
        FirstThread thread1 = new FirstThread();
        SecondThread thread2 = new SecondThread();

        thread1.start();
        thread2.start();

    }

    private static class FirstThread extends Thread{
        @Override
        public void run() {
            synchronized (object1){
                System.out.println("First Thread has object1's lock");

                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("First Thread want to have object2's lock. so wait");

                synchronized (object2){
                    System.out.println("First Thread has object2's lock too");
                }
            }
        }
    }

    private static class SecondThread extends Thread{
        @Override
        public void run() {
            synchronized (object2){
                System.out.println("Second Thread has object2's lock");

                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Second Thread want to have object1's lock, so wait");

                synchronized (object1){
                    System.out.println("Second Thread has object1's lock too");
                }
            }
        }
    }
}

 

 

 

위처럼, object1이 락은 가지고 있으며, object2에 대한 락을 원한다.

 

또한 object2또한 락을 가지고 있고, object1에 대한 락을 원한다. 즉, 서로 상대방이 점유한 자원을 원하여 대기하는 상태이기 때문에 무한정 기다릴 수 밖에 없는 것이다.

 

 

 

 

무한정 대기

 

 

 

 

 

 

 

논블로킹

 

 

🔲 논블로킹이란?

 

다른 쓰레드의 작업 여부와는 상관없이 자신의 작업을 수행하는 방식

 

 

🔲 CAS

 

자원값, 기대값, 새로운 값(연산결과)을 말하며, 자원 값과 기댓값이 같다면 자원 값을 새로운 값으로 수정하고 True반환, 다르다면 수정하지 않고 False 반환

 

 

 

 

 

 

Atomic 타입

 

 

🔲 동시성을 보장하기 위해서 자바에서 제공하는 Wrapper class이다.

 

CAS(Compare and Set) + Volatile

 

 

 

🔶 AtomicReference

 

논블로킹은 AtomicReference를 통해서 동시성을 보장할 수 있다.

 

 

 

 

 

AtomicReference의 내부 value 값의 타입을 살펴보면, volatile이라는 키워드가 붙어있는 것을 볼 수 있다. 앞서 말했듯이 volatile은 Main Memory 상의 진짜 값을 볼 수 있도록 하는 것이라고 하였다.

 

 

즉, JVM 상에서의 현재 변수 값을 각 쓰레드의 CPU 캐시에서의 값과 일치시킬 수 있고, 연산을 할 수 있다.

 

 

연산을 하는 경우 compareAndSet()이라는 함수가 실행되는데, 이를 통해 메모리에 저장된 자원 값과 쓰레드 내부의 기댓 값을 비교한다. 그리고 일치한다면 True를 리턴하고 일치하지 않으면 False를 리턴하는 식으로 동작한다.

 

 

즉, volatile을 통해서 Main Memory 상에서 진짜 값을 확인하는 가시성을 지킬 수 있으며, CAS를 통해서 연산 시마다 비교 알고리즘을 적용해 원자성을 보장할 수 있다.

 

 

 

@RestController
@RequestMapping("/atomic")
public class AtomicController {
    private AtomicInteger studentCount = new AtomicInteger(0);
    
    @PostMapping("/1/increase")
    public ResponseEntity<Void> increaseCount() {
        studentCount.addAndGet(1);
        return ResponseEntity.ok().build();
    }
    
    @GetMapping("/1/count")
    public ResponseEntity<AtomicInteger> getCount() {
        return ResponseEntity.ok(studentCount);
    }
    
}

 

 

 

앞서 보았던, student를 Count하는 예제에서 AtomicInteger로 논블로킹한 상황에서 가시성과 원자성을 지켜주었다.

 

 

 

 

 

 

 

Thread 안전한 객체

 

 

여러 스레드가 동시에 클래스를 사용하려는 상황에서 클래스의 내부 값을 안정적인 상태로 유지하는 것이다.

이러한 객체를 설계하기 위해서는 정말 많은 방법이 있다.(스레드 한정, 락, 자바 모니터 패턴 등등...)

 

 

하지만, 가장 확실한 방법은 공유변수를 최소화하고 캡슐화하며 문서화를 잘하는 것이다.

 

 

 

 

 

 

 

 

 

References

https://math-coding.tistory.com/175

https://www.youtube.com/watch?v=ktWcieiNzKs&list=PL-sctLNt2NB8l7wq5Zh3pAELzL2jFjy_Q&index=2&t=901s