[Java] Java Handler 사용법과 메모리 누수 방지 방법

Java Handler 사용법과 메모리 누수 방지 방법

안녕하세요. 이번 포스팅에서는 Android 개발에서 핵심적인 역할을 하는 Java Handler에 대해 상세히 알아보겠습니다. Handler는 스레드 간 통신과 비동기 작업 처리를 위한 필수 컴포넌트로, 올바르게 이해하고 활용하면 앱의 성능과 사용자 경험을 크게 향상시킬 수 있습니다. 이 글에서는 Handler의 기본 개념부터 실제 활용 방법, 그리고 메모리 누수 방지까지 실무에 필요한 모든 내용을 다루겠습니다.

목차

1. Handler 개념과 필요성

2. Handler 동작 원리와 구조

3. Handler 기본 사용법

4. 실무 활용 패턴과 주의사항

5. 자주 묻는 질문

---

#1. Handler 개념과 필요성

Handler는 안드로이드 프레임워크에서 제공하는 클래스로, 스레드 간 메시지 전달 및 작업 스케줄링을 담당합니다. 안드로이드의 UI는 단일 스레드(메인 스레드)에서만 업데이트할 수 있기 때문에, 백그라운드 스레드에서 UI를 변경하려면 Handler를 통해 메인 스레드로 작업을 전달해야 합니다.

1) Handler가 필요한 이유

안드로이드는 싱글 스레드 모델을 기반으로 하며, 모든 UI 조작은 메인 스레드(UI 스레드)에서만 이루어져야 합니다. 다른 스레드에서 UI를 직접 업데이트하려고 하면 CalledFromWrongThreadException이 발생합니다.

// 잘못된 예: 백그라운드 스레드에서 직접 UI 업데이트
new Thread(new Runnable() {
@Override
public void run() {
textView.setText("백그라운드에서 업데이트"); // 오류 발생!
}
}).start();

(1) 안드로이드 UI 스레드 모델

안드로이드는 성능과 안정성을 위해 UI 업데이트를 단일 스레드에서만 처리합니다. Handler는 이러한 제약 속에서 백그라운드 작업 결과를 UI에 반영할 수 있는 공식적인 방법을 제공합니다.

① 메인 스레드만 UI 업데이트 가능
② 시간이 오래 걸리는 작업은 백그라운드 스레드에서 처리
③ Handler를 통해 스레드 간 통신 수행
④ 지연된 작업이나 반복 작업 스케줄링 가능

. . . . .

2) Handler의 핵심 기능

Handler는 다음과 같은 세 가지 핵심 기능을 제공합니다.

(1) 메시지 전송

한 스레드에서 다른 스레드로 메시지를 전달할 수 있습니다. 이를 통해 백그라운드 작업 결과를 UI 스레드로 안전하게 전달할 수 있습니다.

(2) 작업 스케줄링

특정 시간 후에 작업을 실행하거나 주기적으로 작업을 예약할 수 있습니다. 타이머, 애니메이션, 주기적인 데이터 갱신 등에 유용합니다.

(3) UI 업데이트

백그라운드 스레드에서 수행한 네트워크 요청, 파일 입출력 등의 결과를 UI 스레드로 전달하여 화면을 업데이트할 수 있습니다.

---

#2. Handler 동작 원리와 구조

Handler는 Message 객체를 받아 처리하거나 Runnable 객체를 실행합니다. 이를 위해 내부적으로 MessageQueue와 Looper를 사용합니다.

1) Handler와 Looper의 관계

Handler는 독립적으로 동작할 수 없으며, Looper와 함께 작동합니다. Looper는 메시지 루프를 관리하며, MessageQueue에서 메시지를 꺼내 적절한 Handler에 전달하는 역할을 합니다.

// 일반 스레드에 Looper 설정하기
class LooperThread extends Thread {
public Handler handler;

@Override
public void run() {
Looper.prepare(); // 현재 스레드에 Looper 생성

handler = new Handler(Looper.myLooper()) {
@Override
public void handleMessage(Message msg) {
// 메시지 처리
}
};

Looper.loop(); // 메시지 루프 시작
}
}

(1) Looper의 역할

① MessageQueue에서 메시지를 순차적으로 가져옴
② 각 메시지를 대상 Handler에 전달
③ 한 스레드에는 하나의 Looper만 존재 가능
④ 메인 스레드는 이미 Looper가 설정되어 있음

. . . . .

2) Message와 MessageQueue

Message는 Handler가 처리하는 데이터 객체이며, MessageQueue는 이러한 메시지들을 저장하는 자료구조입니다.

(1) Message 주요 필드

① what: 메시지 유형을 식별하는 정수 값
② arg1, arg2: 추가 정수 파라미터
③ obj: 임의의 객체 참조
④ target: 이 메시지를 처리할 Handler
⑤ callback: 메시지와 함께 실행될 Runnable

// Message 객체 사용 예
Message message = Message.obtain();
message.what = MSG_UPDATE_PROGRESS;
message.arg1 = progressValue;
message.obj = someData;
handler.sendMessage(message);

. . . . .

3) Handler 생명 주기

Handler는 다음과 같은 생명 주기를 가집니다.

(1) 생성 단계

Handler는 Looper가 연결된 스레드에서 생성됩니다. 메인 스레드에서 생성할 경우 자동으로 메인 Looper에 연결됩니다.

(2) 메시지 전송 단계

sendMessage() 또는 post() 메서드를 통해 메시지나 Runnable이 MessageQueue에 추가됩니다.

(3) 메시지 처리 단계

Looper가 MessageQueue에서 메시지를 꺼내 Handler의 handleMessage() 메서드를 호출합니다.

---

#3. Handler 기본 사용법

Handler를 사용하는 방법은 크게 메시지 기반 방식과 Runnable 기반 방식 두 가지로 나눌 수 있습니다.

1) 메시지 기반 방식

메시지 기반 방식은 Message 객체를 사용하여 데이터를 전달하는 방식입니다. 여러 종류의 메시지를 구분하여 처리할 때 유용합니다.

// 1. Handler 정의
private static final int MSG_UPDATE_UI = 1;
private Handler handler = new Handler(Looper.getMainLooper()) {
@Override
public void handleMessage(Message msg) {
if (msg.what == MSG_UPDATE_UI) {
// UI 업데이트 로직
TextView textView = findViewById(R.id.textView);
textView.setText((String) msg.obj);
}
}
};

// 2. 백그라운드 스레드에서 메시지 전송
new Thread(new Runnable() {
@Override
public void run() {
// 시간이 걸리는 작업 수행
String result = performLongTask();

// UI 업데이트를 위한 메시지 전송
Message message = Message.obtain();
message.what = MSG_UPDATE_UI;
message.obj = result;
handler.sendMessage(message);
}
}).start();

. . . . .

2) Runnable 기반 방식

Runnable 기반 방식은 더 간단하고 직관적인 방법입니다. 단순한 UI 업데이트에 적합합니다.

// Handler 생성
private Handler handler = new Handler(Looper.getMainLooper());

// 백그라운드 스레드에서 Runnable 전송
new Thread(new Runnable() {
@Override
public void run() {
// 시간이 걸리는 작업 수행
final String result = performLongTask();

// UI 스레드에서 실행할 Runnable 전송
handler.post(new Runnable() {
@Override
public void run() {
// UI 업데이트 로직
TextView textView = findViewById(R.id.textView);
textView.setText(result);
}
});
}
}).start();

. . . . .

3) 지연된 작업 실행

Handler를 사용하면 특정 시간 후에 작업을 실행할 수 있습니다. 스플래시 화면 구현이나 타이머 기능에 유용합니다.

// 2초 후에 작업 실행
handler.postDelayed(new Runnable() {
@Override
public void run() {
// 지연 후 실행할 코드
showToast("2초가 지났습니다!");
}
}, 2000); // 2000 밀리초 = 2초

. . . . .

4) 반복 작업 처리

Handler를 사용하여 주기적으로 반복되는 작업을 구현할 수 있습니다. 실시간 데이터 업데이트나 애니메이션에 활용됩니다.

private static final int INTERVAL = 1000; // 1초
private Handler handler = new Handler(Looper.getMainLooper());
private int counter = 0;

private Runnable updateTask = new Runnable() {
@Override
public void run() {
// 수행할 작업
updateCounter(counter++);

// 다음 실행 예약
handler.postDelayed(this, INTERVAL);
}
};

// 반복 작업 시작
public void startRepeatingTask() {
updateTask.run();
}

// 반복 작업 중지
public void stopRepeatingTask() {
handler.removeCallbacks(updateTask);
}

---

#4. 실무 활용 패턴과 주의사항

Handler를 실무에서 활용할 때는 메모리 누수 방지와 생명주기 관리가 매우 중요합니다. 잘못 사용하면 메모리 누수가 발생하여 앱 성능이 저하될 수 있습니다.

1) 메모리 누수 방지 방법

익명 내부 클래스로 Handler를 구현할 경우, 외부 Activity/Fragment에 대한 참조를 유지하게 되어 GC가 제대로 이루어지지 않을 수 있습니다.

(1) Static 내부 클래스와 WeakReference 사용

public class MyActivity extends AppCompatActivity {
private TextView resultView;
private MyHandler handler;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

resultView = findViewById(R.id.result_view);
handler = new MyHandler(this);
}

@Override
protected void onDestroy() {
super.onDestroy();
// 모든 콜백 및 메시지 제거
handler.removeCallbacksAndMessages(null);
}

// Static 내부 클래스로 Handler 구현
private static class MyHandler extends Handler {
// Activity에 대한 약한 참조
private final WeakReference<MyActivity> activityRef;

MyHandler(MyActivity activity) {
super(Looper.getMainLooper());
this.activityRef = new WeakReference<>(activity);
}

@Override
public void handleMessage(Message msg) {
MyActivity activity = activityRef.get();
if (activity == null) return; // Activity가 파괴된 경우

// 메시지 처리
if (msg.what == MSG_UPDATE_UI) {
activity.resultView.setText((String) msg.obj);
}
}
}
}

. . . . .

2) 생명주기에 맞춰 Handler 정리하기

Activity나 Fragment가 종료될 때는 반드시 Handler의 모든 콜백과 메시지를 제거해야 합니다. 그렇지 않으면 이미 파괴된 컴포넌트에 접근하려다 오류가 발생할 수 있습니다.

@Override
protected void onDestroy() {
super.onDestroy();
// 모든 지연된 메시지와 콜백 제거
handler.removeCallbacksAndMessages(null);
}

. . . . .

3) Handler vs 다른 비동기 처리 방식

안드로이드에서는 Handler 외에도 다양한 비동기 처리 방식이 있습니다. 상황에 맞는 적절한 방법을 선택하는 것이 중요합니다.

방식	장점	단점	적합한 사용 사례
Handler	세밀한 제어 가능, 스레드 간 통신 용이	직접 관리 필요, 메모리 누수 가능성	UI 업데이트, 지연된 작업, 반복 작업
AsyncTask	간단한 사용법, 진행 상태 업데이트 쉬움	API 29에서 deprecated	더 이상 권장되지 않음
Executor	간결한 API, 스레드 풀 관리	UI 업데이트에 추가 단계 필요	다수의 백그라운드 작업
Coroutines	간결한 코드, 취소 관리 용이	Java에서 사용 제한적	복잡한 비동기 작업
RxJava	강력한 스트림 처리, 조합 가능	학습 곡선 높음, 복잡성	복잡한 이벤트 처리

(1) Handler를 사용해야 하는 경우

① UI 스레드와 직접 통신이 필요할 때
② 세밀한 타이밍 제어가 필요한 작업
③ 간단한 지연 작업이나 반복 작업
④ 낮은 수준의 스레드 통신이 필요할 때

. . . . .

4) 실무 활용 예제

실제 개발에서 자주 사용되는 Handler 활용 패턴을 살펴보겠습니다.

(1) 스플래시 화면 구현

public class SplashActivity extends AppCompatActivity {
private static final long SPLASH_DELAY = 2000; // 2초
private Handler handler = new Handler(Looper.getMainLooper());

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_splash);

handler.postDelayed(new Runnable() {
@Override
public void run() {
startActivity(new Intent(SplashActivity.this, MainActivity.class));
finish();
}
}, SPLASH_DELAY);
}

@Override
protected void onDestroy() {
super.onDestroy();
handler.removeCallbacksAndMessages(null);
}
}

(2) 실시간 데이터 업데이트

public class RealTimeUpdateActivity extends AppCompatActivity {
private static final int UPDATE_INTERVAL = 1000; // 1초
private Handler handler = new Handler(Looper.getMainLooper());
private TextView dataView;
private boolean isUpdating = false;

private Runnable updateRunnable = new Runnable() {
@Override
public void run() {
// 수행할 작업
updateData();

if (isUpdating) {
handler.postDelayed(this, UPDATE_INTERVAL);
}
}
};

@Override
protected void onResume() {
super.onResume();
isUpdating = true;
handler.post(updateRunnable);
}

@Override
protected void onPause() {
super.onPause();
isUpdating = false;
handler.removeCallbacks(updateRunnable);
}
}

(3) 네트워크 타임아웃 처리

public void performNetworkRequest() {
final Handler timeoutHandler = new Handler(Looper.getMainLooper());
final Runnable timeoutRunnable = new Runnable() {
@Override
public void run() {
// 타임아웃 처리
showTimeoutError();
cancelRequest();
}
};

// 10초 후 타임아웃 설정
timeoutHandler.postDelayed(timeoutRunnable, 10000);

// 네트워크 요청 시작
startNetworkRequest(new Callback() {
@Override
public void onResponse(Response response) {
// 타임아웃 취소
timeoutHandler.removeCallbacks(timeoutRunnable);
processResponse(response);
}

@Override
public void onFailure(Exception e) {
// 타임아웃 취소
timeoutHandler.removeCallbacks(timeoutRunnable);
handleError(e);
}
});
}

---

#5. 자주 묻는 질문

1) Q: Handler는 항상 UI 스레드에서만 사용해야 하나요?

A: 아닙니다. Handler는 어떤 스레드에서도 사용할 수 있지만, 해당 스레드에 Looper가 설정되어 있어야 합니다. 메인 스레드(UI 스레드)는 기본적으로 Looper가 설정되어 있지만, 다른 스레드에서는 Looper.prepare()와 Looper.loop()를 호출하여 Looper를 설정해야 합니다.

. . . . .

2) Q: HandlerThread는 무엇인가요?

A: HandlerThread는 자체적으로 Looper를 갖는 Thread의 확장 클래스입니다. 기본 스레드와 달리 자동으로 Looper를 설정하고 시작하므로, Handler를 쉽게 연결할 수 있습니다.

HandlerThread handlerThread = new HandlerThread("BackgroundThread");
handlerThread.start();

Handler backgroundHandler = new Handler(handlerThread.getLooper());
backgroundHandler.post(new Runnable() {
@Override
public void run() {
// 백그라운드에서 실행될 코드
}
});

. . . . .

3) Q: postDelayed와 sendMessageDelayed의 차이점은 무엇인가요?

A: 둘 다 지연된 작업을 예약하는 메서드이지만, postDelayed는 Runnable을 사용하고 sendMessageDelayed는 Message 객체를 사용합니다. Runnable 방식이 더 간단하지만, Message 방식은 더 많은 데이터를 전달할 수 있고 what 필드를 통해 메시지 유형을 구분할 수 있습니다.

. . . . .

4) Q: Handler를 사용할 때 메모리 누수를 방지하는 방법은 무엇인가요?

A: 메모리 누수를 방지하기 위한 주요 방법은 다음과 같습니다.

① Static 내부 클래스와 WeakReference 사용
② Activity/Fragment 생명주기에 맞춰 Handler 콜백 제거
③ 적절한 시점에 removeCallbacksAndMessages(null) 호출
④ onDestroy()에서 모든 지연된 작업 취소

. . . . .

5) Q: 안드로이드 API 30 이상에서 Handler 사용 시 주의할 점이 있나요?

A: API 30 이상에서는 Handler 생성자 사용 시 Looper를 명시적으로 지정하는 것이 권장됩니다. 또한 Handler.Callback 인터페이스를 구현하는 방식도 권장됩니다.

// 권장되는 방식
Handler handler = new Handler(Looper.getMainLooper(), new Handler.Callback() {
@Override
public boolean handleMessage(@NonNull Message msg) {
// 메시지 처리
return true; // 메시지가 처리되었음을 표시
}
});

. . . . .

6) Q: Handler로 반복 작업을 할 때 CPU 사용량이 걱정됩니다

A: Handler를 사용한 반복 작업은 postDelayed를 사용하여 적절한 간격을 두고 실행하면 CPU 사용량 문제를 피할 수 있습니다. 무한 루프가 아닌 지연된 재귀 호출 방식으로 작동하기 때문에 CPU에 부담을 주지 않습니다. 다만 반복 간격이 너무 짧으면(예: 10ms 이하) 성능에 영향을 줄 수 있으므로 적절한 간격(보통 100ms 이상)을 설정해야 합니다.

. . . . .

7) Q: 여러 개의 Handler를 사용할 수 있나요?

A: 네, 하나의 Activity나 Fragment에서 여러 개의 Handler를 사용할 수 있습니다. 각 Handler는 독립적으로 동작하며, 서로 다른 목적을 위해 여러 Handler를 만들어 사용하는 것이 일반적입니다. 예를 들어 UI 업데이트용 Handler와 네트워크 타임아웃용 Handler를 별도로 만들 수 있습니다.

. . . . .

8) Q: Handler를 사용하면 ANR이 발생할 수 있나요?

A: Handler 자체는 ANR을 발생시키지 않습니다. 그러나 handleMessage() 메서드 내에서 시간이 오래 걸리는 작업을 수행하면 메인 스레드가 블로킹되어 ANR이 발생할 수 있습니다. handleMessage()에서는 UI 업데이트 등 빠른 작업만 수행하고, 무거운 작업은 여전히 백그라운드 스레드에서 처리해야 합니다.

---

마무리

Java Handler는 안드로이드 애플리케이션 개발에서 스레드 간 통신과 비동기 작업 처리를 위한 핵심 컴포넌트입니다. 메인 스레드와 백그라운드 스레드 간의 원활한 통신, 지연된 작업 실행, 반복 작업 처리 등 다양한 상황에서 유용하게 활용될 수 있습니다.

Handler를 효과적으로 사용하기 위해서는 Looper, Message, MessageQueue의 개념과 동작 원리를 이해하는 것이 중요합니다. 또한 메모리 누수와 같은 잠재적인 문제를 방지하기 위해 정적 내부 클래스와 WeakReference를 사용하고, 생명주기에 맞춰 적절히 정리하는 것이 필수적입니다.

최신 안드로이드 개발에서는 Kotlin Coroutines나 RxJava와 같은 대안이 있지만, Handler는 여전히 많은 상황에서 유용하며 안드로이드 프레임워크의 기본 구성 요소로 동작합니다. 따라서 모든 안드로이드 개발자는 Handler의 기본 개념과 사용법을 숙지하는 것이 중요합니다.

이 글에서 다룬 내용을 정리하면 다음과 같습니다.

① Handler는 스레드 간 통신을 위한 필수 도구
② Looper와 MessageQueue를 통해 메시지 처리
③ 메시지 기반 방식과 Runnable 기반 방식 선택 가능
④ 메모리 누수 방지를 위한 적절한 패턴 사용 필수
⑤ 생명주기에 맞춰 Handler 정리 필요

실무에서 Handler를 사용할 때는 단순히 동작하는 코드를 작성하는 것을 넘어, 메모리 관리와 성능 최적화를 함께 고려해야 합니다. 이 글에서 소개한 베스트 프랙티스를 따라 안전하고 효율적인 코드를 작성하시기 바랍니다.

긴 글 읽어주셔서 감사합니다.

끝.