📚 [Java] - synchronized

CodeByHan·2025년 11월 8일

자바

목록 보기

10/13

자바 멀티스레드 환경에서 프로그램을 만들다 보면, 의도치 않은 결과가 나오는 경우가 많다. 이런 상황에서 자주 등장하는 키워드가 있다. 바로 synchronized다. 오늘은 synchronized를 조금 더 깊게 정리해보려고 한다.

자바의 메모리 영역

synchronized를 이해하려면 먼저 자바의 메모리 구조를 아는 것이 도움이 된다.

자바 메모리는 크게 Stack, Heap, Method Area로 구분된다. 멀티스레드 환경에서는 스레드들이 Heap과 Method Area를 공유하지만, Stack은 각 스레드마다 고유하게 존재한다.

따라서 여러 스레드가 공유 자원에 접근할 때는 동기화 문제를 주의해야 한다.

이러한 동기화 문제를 해결해주는 것이 바로 synchronized 키워드다.

메서드 영역: 전역 변수 , static 변수 저장, 프로그램 시작부터 종료까지 메모리에 남아있다.
스택 영역: 지역 변수, 매개변수 데이터 값이 저장되는 공간, 메서드가 호출될 때 메모리에 할당 되고 종료되면 메모리가 해제 된다.
힙 영역: new 키워드로 생성되는 객체(인스턴스), 배열 등이 저장되며, 가비지 컬렉션에 의해 메모리가 관리된다.

synchronized method

public static void main(String[] args) {

    SyncDemo demo = new SyncDemo();
    Thread tA = new Thread(() -> {
        System.out.println("Thread-A 시작: " + LocalDateTime.now());
        demo.firstMethod("Thread-A");
        System.out.println("Thread-A 종료: " + LocalDateTime.now());
    });

    Thread tB = new Thread(() -> {
        System.out.println("Thread-B 시작: " + LocalDateTime.now());
        demo.secondMethod("Thread-B");
        System.out.println("Thread-B 종료: " + LocalDateTime.now());
    });

    tA.start();
    tB.start();
}

private synchronized void firstMethod(String name) {
    System.out.println(name + " -> firstMethod 실행 중: " + LocalDateTime.now());
    try {
        TimeUnit.SECONDS.sleep(5);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

private synchronized void secondMethod(String name) {
    System.out.println(name + " -> secondMethod 실행 중: " + LocalDateTime.now());
    try {
        TimeUnit.SECONDS.sleep(5);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

SyncDemo 인스턴스를 한개 생성하고, 두 개의 스레드를 만들어 각각 synchronized 키워드가 붙은 ThreadA, ThreadB 를 호출해보았다.

확인 결과, ThreadA 호출 -> 종료 된 후, 다음 ThreadB 가 호출 -> 종료 되는 것을 확인 할 수 있다.

만약 인스턴스를 각각 만들고, 스레드들을 호출하게 한다면 어떻게 될까?

public static void main(String[] args) {

    SyncDemo demo1 = new SyncDemo();
    SyncDemo demo2 = new SyncDemo();

    Thread tA = new Thread(() -> {
        System.out.println("Thread-A 시작: " + LocalDateTime.now());
        demo1.firstMethod("Thread-A");
        System.out.println("Thread-A 종료: " + LocalDateTime.now());
    });

    Thread tB = new Thread(() -> {
        System.out.println("Thread-B 시작: " + LocalDateTime.now());
        demo2.secondMethod("Thread-B");
        System.out.println("Thread-B 종료: " + LocalDateTime.now());
    });

    tA.start();
    tB.start();
}

private synchronized void firstMethod(String name) {
    System.out.println(name + " -> firstMethod 실행 중: " + LocalDateTime.now());
    try {
        TimeUnit.SECONDS.sleep(5);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

private synchronized void secondMethod(String name) {
    System.out.println(name + " -> secondMethod 실행 중: " + LocalDateTime.now());
    try {
        TimeUnit.SECONDS.sleep(5);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

이 경우, 각 스레드는 서로 다른 객체의 lock을 사용하기 때문에 스레드 간 동기화가 발생하지 않는다. 결과에서 확인할 수 있듯이, synchronized 메서드는 해당 인스턴스에 lock을 건다.

여기서 “인스턴스에 lock을 건다”는 표현 때문에, 마치 인스턴스 자체에 접근이 불가능해지는 것처럼 오해할 수 있지만, 실제로는 메서드 실행 시에만 lock이 적용된다.

한번 코드로 확인해보자!!

public static void main(String[] args) {

    SyncDemo demo = new SyncDemo(); // 하나의 객체만 생성

    Thread tA = new Thread(() -> {
        System.out.println("Thread-A 시작: " + LocalDateTime.now());
        demo.firstMethod("Thread-A");
        System.out.println("Thread-A 종료: " + LocalDateTime.now());
    });

    Thread tB = new Thread(() -> {
        System.out.println("Thread-B 시작: " + LocalDateTime.now());
        demo.secondMethod("Thread-B");
        System.out.println("Thread-B 종료: " + LocalDateTime.now());
    });

    Thread tC = new Thread(() -> {
        System.out.println("Thread-C 시작: " + LocalDateTime.now());
        demo.thirdMethod("Thread-C");
        System.out.println("Thread-C 종료: " + LocalDateTime.now());
    });

    tA.start();
    tB.start();
    tC.start();
}

private synchronized void firstMethod(String name) {
    System.out.println(name + " -> firstMethod 실행 중: " + LocalDateTime.now());
    try {
        TimeUnit.SECONDS.sleep(5);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

private synchronized void secondMethod(String name) {
    System.out.println(name + " -> secondMethod 실행 중: " + LocalDateTime.now());
    try {
        TimeUnit.SECONDS.sleep(5);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

private void thirdMethod(String name) {
    System.out.println(name + " -> thirdMethod 실행 중: " + LocalDateTime.now());
    try {
        TimeUnit.SECONDS.sleep(5);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

이 코드에서 Thread-C는 thirdMethod를 실행하는데, 이 메서드는 synchronized가 붙지 않은 일반 메서드다.
따라서 Thread-C에는 락이 걸리지 않고, 다른 스레드(firstMethod, secondMethod)와 동시에 실행될 수 있음을 확인할 수 있다.

결과를 보면 알 수 있듯이, synchronized 메서드는 객체(인스턴스) 단위로 락을 건다.

하지만 락은 synchronized 키워드가 붙은 메서드끼리만 공유되므로, 일반 메서드에는 락이 적용되지 않는다.

결론

synchronized 키워드가 붙은 메서드는 해당 객체에 락을 걸어 한 번에 하나의 스레드만 실행할 수 있도록 한다.
즉, 같은 객체의 synchronized 메서드는 동시에 실행되지 않는다.

서로 다른 객체의 synchronized 메서드는 각각 별도의 락을 사용하기 때문에 동시에 실행될 수 있다.
따라서, synchronized 메서드 동기화는 객체 단위라는 점이 중요하다.
동기화 범위는 synchronized 메서드에 한정
일반 메서드는 락과 상관없이 언제든 동시에 실행 가능하다.
락은 synchronized가 붙은 메서드끼리만 공유된다.

static synchronized method

public static void main(String[] args) {
    Thread tA = new Thread(() -> {
        System.out.println("Thread-A 시작: " + LocalDateTime.now());
        syncMethodA("Thread-A");
        System.out.println("Thread-A 종료: " + LocalDateTime.now());
    });

    Thread tB = new Thread(() -> {
        System.out.println("Thread-B 시작: " + LocalDateTime.now());
        syncMethodB("Thread-B");
        System.out.println("Thread-B 종료: " + LocalDateTime.now());
    });

    tA.start();
    tB.start();
}

public static synchronized void syncMethodA(String name) {
    System.out.println(name + " -> syncMethodA 실행 중: " + LocalDateTime.now());
    try {
        TimeUnit.SECONDS.sleep(5);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

public static synchronized void syncMethodB(String name) {
    System.out.println(name + " -> syncMethodB 실행 중: " + LocalDateTime.now());
    try {
        TimeUnit.SECONDS.sleep(5);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

결과를 보면 알 수 있듯이, static 키워드가 붙은
synchronized 메서드는 인스턴스가 아닌 클래스 단위로 lock을 공유한다.

따라서 static synchronized를 사용하면, 여러 객체가 존재해도 클래스 단위로 안전하게 동기화를 보장할 수 있다.

여기다가 일반 synchronized 메서드를 추가한다면 어떻게 될까?

public static void main(String[] args) {
    StaticLockDemo demo = new StaticLockDemo();

    Thread t1 = new Thread(() -> {
        System.out.println("Thread-1 시작: " + LocalDateTime.now());
        syncStaticA("Thread-1");
        System.out.println("Thread-1 종료: " + LocalDateTime.now());
    });

    Thread t2 = new Thread(() -> {
        System.out.println("Thread-2 시작: " + LocalDateTime.now());
        syncStaticB("Thread-2");
        System.out.println("Thread-2 종료: " + LocalDateTime.now());
    });

    Thread t3 = new Thread(() -> {
        System.out.println("Thread-3 시작: " + LocalDateTime.now());
        demo.syncC("Thread-3");
        System.out.println("Thread-3 종료: " + LocalDateTime.now());
    });

    t1.start();
    t2.start();
    t3.start();
}

public static synchronized void syncStaticA(String name) {
    System.out.println(name + " -> syncStaticA 실행 중: " + LocalDateTime.now());
    try {
        TimeUnit.SECONDS.sleep(5);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

public static synchronized void syncStaticB(String name) {
    System.out.println(name + " -> syncStaticB 실행 중: " + LocalDateTime.now());
    try {
        TimeUnit.SECONDS.sleep(5);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

private synchronized void syncC(String name) {
    System.out.println(name + " -> syncC 실행 중: " + LocalDateTime.now());
    try {
        TimeUnit.SECONDS.sleep(5);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

syncStaticA 과 syncStaticB는 동기화가 잘 지켜지는걸 확인 할 수 있지만 일반 synchronized인 syncC는 지켜지지 않는걸 확인 할 수 있다.

클래스 단위로 락을 거는 static synchronized와 인스턴스 단위로 락을 거는 일반 synchronized를 혼용할 경우, 어느 락이 적용되는지 헷갈릴 수 있으므로 주의하자.

synchronized block

synchronized block은 메서드 전체가 아닌, 코드 블록 단위로 동기화를 적용할 수 있는 방법이다.

synchronized(this)

public static void main(String[] args) {

    SyncBlockDemo demo = new SyncBlockDemo();

    Thread t1 = new Thread(() -> {
        System.out.println("Thread-A 시작 " + LocalDateTime.now());
        demo.lockBlockA("Thread-A");
        System.out.println("Thread-A 종료 " + LocalDateTime.now());
    });

    Thread t2 = new Thread(() -> {
        System.out.println("Thread-B 시작 " + LocalDateTime.now());
        demo.lockBlockB("Thread-B");
        System.out.println("Thread-B 종료 " + LocalDateTime.now());
    });

    t1.start();
    t2.start();
}

private void lockBlockA(String name) {
    synchronized (this) {
        System.out.println(name + " -> lockBlockA 실행 중 " + LocalDateTime.now());
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

private void lockBlockB(String name) {
    synchronized (this) {
        System.out.println(name + " -> lockBlockB 실행 중 " + LocalDateTime.now());
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

위와 같이 synchronized 블록에서 this를 사용하면, 모든 해당 객체의 synchronized 블록에 같은 락이 걸리게 된다.

즉, 여러 스레드가 서로 다른 synchronized 블록을 호출하더라도, this에 락이 걸려 있기 때문에 순차적으로 실행해야 한다.

synchronized(Object)

public class LockBlockDemo {

    private final Object lockA = new Object();
    private final Object lockB = new Object();

    public static void main(String[] args) {

        LockBlockDemo demo = new LockBlockDemo();

        Thread t1 = new Thread(() -> {
            System.out.println("Thread-1 시작 " + LocalDateTime.now());
            demo.blockA("Thread-1");
            System.out.println("Thread-1 종료 " + LocalDateTime.now());
        });

        Thread t2 = new Thread(() -> {
            System.out.println("Thread-2 시작 " + LocalDateTime.now());
            demo.blockB("Thread-2");
            System.out.println("Thread-2 종료 " + LocalDateTime.now());
        });

        t1.start();
        t2.start();
    }

    private void blockA(String name) {
        synchronized (lockA) {
            System.out.println(name + " -> blockA 실행 중 " + LocalDateTime.now());
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private void blockB(String name) {
        synchronized (lockB) {
            System.out.println(name + " -> blockB 실행 중 " + LocalDateTime.now());
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Thread-1과 Thread-2가 동시에 실행되는 것을 보면, 동기화가 적용되지 않은 것을 확인할 수 있다.

this 대신 lockA, lockB와 같은 별도의 객체를 락으로 사용하면, 동시에 락을 걸어야 하는 부분을 개별적으로 지정할 수 있다.

싱글톤(Singleton) 객체의 동기화

public class SimpleSingleton {

    private static SimpleSingleton sSimpleSingleton;

    public static SimpleSingleton getInstance() {
        if (Objects.isNull(sSimpleSingleton)) {
            sSimpleSingleton = new SimpleSingleton();
        }
        return sSimpleSingleton;
    }
}

싱글톤 객체를 만드는 가장 쉬운 방법으로 코드를 짜봤다.

하지만 멀티스레드 환경에서 여러 스레드가 동시에 getInstance()를 호출하면 동시 접근 문제(race condition) 발생 가능하다.

여기서 이제 두가지 해결 방법이 존재한다.

바로 메서드에 synchronized 키워드를 붙이거나, Double-Checked Locking (DCL) , LazyHolder를 사용하는 방법이다.

일단 synchronized 키워드 를 붙여보자

public static synchronized SimpleSingleton getInstance() {
    if (Objects.isNull(sSimpleSingleton)) {
        sSimpleSingleton = new SimpleSingleton();
    }
    return sSimpleSingleton;
}

하지만 인스턴스가 이미 생성된 이후에도, 모든 스레드가 synchronized를 거쳐야 하기 때문에 성능 저하가 발생할 수 있다.

특히 getInstance()를 자주 호출하는 상황에서는, 불필요한 락 비용이 반복적으로 발생하게 된다.

Double-Checked Locking (DCL)

public class DCLSingleton {

    // volatile 키워드로 멀티스레드에서 안전하게
    private static volatile DCLSingleton instance;

    private DCLSingleton() {}

    public static DCLSingleton getInstance() {
        if (instance == null) {                  // 1차 체크 (락 걸기 전)
            synchronized (DCLSingleton.class) {  // 클래스 단위로 락
                if (instance == null) {          // 2차 체크 (락 안에서)
                    instance = new DCLSingleton();
                }
            }
        }
        return instance;
    }
}

Double-Checked Locking(DCL)은 메서드 전체에 synchronized를 걸지 않고, 동기화 오버헤드를 줄이기 위해 설계된 방식이다.

최초 인스턴스가 생성된 이후에는 동기화 블록에 진입하지 않아 성능을 최적화 시도

하지만 주의할 점이 있다.

멀티스레드 환경에서 Thread A가 인스턴스를 생성하는 도중 Thread B가 이미 할당된 인스턴스를 접근할 수 있다.

이 경우, 인스턴스가 완전히 초기화되기 전에 사용되므로 오동작이 발생할 수 있다.

확률은 낮지만, 안전성을 위해 적절한 처리(예: volatile 선언) 없이 사용하는 것은 권장되지 않는다.

LazyHolder(추천)

public class LazyHolderSingleton {


    private LazyHolderSingleton() {
    }

    // 중첩(static) 클래스에 인스턴스 생성
    private static class Holder {
        private static final LazyHolderSingleton INSTANCE = new LazyHolderSingleton();
    }

    // 외부에서 호출 시 Holder 클래스가 로딩되면서 인스턴스 생성
    public static LazyHolderSingleton getInstance() {
        return Holder.INSTANCE;
    }
}

개발자가 직접 동기화 문제를 코드로 처리하려고 하면, 프로그램 구조가 복잡해지고, 성능 비용이 발생할 수 있으며, 특히 정확하게 구현하기 어려운 경우가 많다.

LazyHolder 방식은 이러한 문제를 피하고, JVM의 클래스 초기화 과정에서 보장되는 원자적 특성을 이용해 싱글톤 초기화 책임을 JVM에게 맡기는 방법이다.

Singleton 클래스 자체에는 LazyHolder 클래스의 변수가 없음 → Singleton 클래스 로딩 시점에서는 Holder 클래스가 초기화되지 않음

getInstance() 메서드에서 Holder.INSTANCE를 참조하는 순간, Holder 클래스가 로딩되고 인스턴스 초기화가 진행됨

클래스 로딩과 초기화 과정은 JVM에 의해 동기화가 보장되므로, volatile이나 synchronized 키워드를 사용하지 않아도 멀티스레드 안전성을 유지하면서 성능도 우수하다.

🧹 정리

1. 왜 자바에서 동기화 문제를 신경 써야 할까?

자바에서 멀티 스레드 환경이 되면, 스레드들이 힙 영역과 메서드(method) 영역을 공유하게 된다.

즉, 여러 스레드가 동시에 같은 데이터를 읽거나 쓸 수 있기 때문에, 공유 자원에 대한 동기화를 반드시 고려해야 한다.

2. synchronized 키워드란?

synchronized는 락(lock)을 사용해 동시 접근을 제어하는 키워드다.

주요 사용 방법은 네 가지가 있다.

1. synchronized method

메서드 선언부에 synchronized를 붙이면, 동일 인스턴스의 메서드끼리만 lock을 공유한다.
다른 인스턴스에서는 영향을 받지 않으므로, 인스턴스별로 독립적인 락이 걸린다.

2. static synchronized method

클래스 단위로 lock이 걸리며, 인스턴스 락과는 별도로 동작한다.
클래스 메서드 간의 동기화는 보장되지만, 인스턴스 메서드와는 lock이 공유되지 않는다.

3. synchronized block

필요한 코드 블록만 락으로 감싸서 동기화를 제어할 수 있다.
방법 1: this를 사용 → 현재 객체를 락으로 사용. 다른 block도 같은 객체를 사용하면 대기해야 함
방법 2: 별도 Object를 락으로 사용 → 블록별로 독립적인 lock을 걸 수 있어 효율적

4. static synchronized block

static synchronized method처럼 클래스 단위로 lock을 공유
다만 block 단위로 lock 범위를 지정할 수 있어, 세밀한 제어가 가능하다

3. Singleton 객체에서 synchronized를 쓰면 생기는 문제

synchronized 메서드가 많으면, 멀티 스레드 환경에서도 병목 현상이 발생

쉽게 말해, 멀티 스레드처럼 동작하지만 사실상 싱글 스레드처럼 느려짐

📄 해결하는 방법

-> LazyHolder 패턴을 사용

JVM의 클래스 초기화 시점에서 보장되는 thread-safe 특성을 이용해 초기화

개발자가 직접 synchronized 코드를 작성하지 않아도 됨 → 복잡성 감소

Holder 클래스의 인스턴스는 getInstance() 호출 시점에만 생성 → 메모리 효율도 좋음

참고

Java의 동기화 Synchronized 개념 정리#2
출처: https://tourspace.tistory.com/55?category=788398 [투덜이의 리얼 블로그:티스토리]

[읽고서] 자바 고유락과 Synchronization

[Java] 혼동되는 synchronized 동기화 정리

CodeByHan

노력은 배신하지 않아 🔥

이전 포스트

📚 [Java] - 오버로딩(Overloading), 오버라이딩(Overriding)

다음 포스트