레이블이 동기화인 게시물을 표시합니다. 모든 게시물 표시
레이블이 동기화인 게시물을 표시합니다. 모든 게시물 표시

2018년 1월 15일 월요일

[안드로이드] 스레드3 - 기본 스레드의 생명주기 관리

기본 스레드의 관리

  • 안드로이드에서도 자바와 마찬가지로 java.lang.Thread 클래스가 모든 스레드의 근간이 된다.

1.기본개념

생명주기

  • Thread.State enum에 정의되어 있으며, Thread 인스턴스의 getStatus() 메서드를 이용해 확인할 수 있다.

NEW

  • Thread 클래스의 인스턴스를 생성한 직후의 상태
  • Thread 인스턴스 생성이 다른 클래스의 인스턴스 생성보다 무겁지는 않다.
  • 생성된 스레드는 현재 스레드와 동일한 우선순위의 스레드그룹으로 할당된다.
    • ex) UI스레드에서 생성하면 UI스레드와 동일한 우선순위의 스레드그룹이 된다.

RUNNABLE

  • Thread.start() 메서드가 호출되어 실행환경이 설정된 직후부터 스레드가 실행되는 중의 상태
  • 이후에 OS의 스케쥴러가 스레드를 선택하면 run() 메서드가 호출되어 태스크가 실행된다.

BLOCK / WAITING / TIMED_WAITING

  • I/O 동작, 다른스레드와의 자원동기화, 블로킹 API호출 등 스레드의 실행이 멈출 때의 상태들
  • 스레드를 명시적으로 실행을 멈추는 방법
    • Thread.sleep() : 스레드를 일정시간 동안 자도록 만든후 다시 실행하도록 스케쥴되도록 함
    • Thread.yield() : 현재 실행을 포기하고 스케줄러가 어떤 스레드를 실행할지 결정하도록 함

TERMINATED

  • run() 메서드가 실행을 완료하면 스레드가 종료되고 스레드의 자원이 해제된 후의 상태
  • 스레드가 종료되고 나면 해당 스레드의 인스턴스와 실행환경은 재사용할 수 없다.
  • 실행환경을 설정/해제하는 것은 매우 무거운 동작
  • 스레드가 동작을 명시적으로 종료하도록 요청할 수도 있다. - interrupt() 메서드 호출

인터럽트

  • 스레드를 명시적으로 종료하고 싶을 때, 스레드에 interrupt() 메서드를 이용해 인터럽트를 요청
  • 어디까지나 요청일 뿐, 인터럽트 호출에 대한 실행여부는 스레드 자체가 결정한다.
  • 일반적으로 스레드의 인터럽트는 공동으로(Collaboratively) 구현되어야 한다.
class TestThread extends Thread {
    @Override
    public void run() {
        //isInterrupt() 메서드를 수시로 검사하여 true를 반환하면 태스크를 완료한 것으로 처리
        while(!isInterrunpted()) {
            //스레드가 살아있음
        }
        //태스크 완료되어 스레드 종료됨
    }
}
  • 스레드 내에서 블로킹 API를 사용중이라 스레드가 차단되어있는 중에 인터럽트 신호를 받으면 블로킹 API는 InterruptException 을 던진다.
    • InterruptException이 던져지면 인터럽트 플래그가 리셋되므로 주의한다.
class TestThread extends Thread {
    @Override
    public void run() {
        //isInterrupt() 메서드를 수시로 검사하여 true를 반환하면 태스크를 완료한 것으로 처리
        while(!isInterrunpted()) {
            doBlockingAction();
        }
    }
    
    public void doBlockingAction() {
        try {
            //Blocking API 호출
        } catch (InterruptException e) {
            //1.자원 정리
            //2.isInterrupt() 플래그가 초기화되었으므로, run() 메서드가 isInterrupt()를 제대로 인식하도록 자신을 다시 인터럽트
            Thread.currentThread().interrupt();
        }
    }
}

잡히지 않는 예외

  • 모든 스레드는 RuntimeException이 발생했을 때, 이 예외를 처리해주지 않으면 스레드가 비정상적으로 종료된다.
  • 스레드 내에서 발생하는 RuntimeException을 잡으려면, 스레드가 비정상 종료되기 전에 호출되는 UncaughtExceptionHandler를 부착한다.
    • 모든 스레드에 전역 핸들러를 부착할 경우 : Thread 클래스의 setDefaultUncaughtExceptionHandler() 정적 메서드 호출
    • 특정 스레드에 지역 핸들러를 부착할 경우 : Thread 인스턴스의 setUncaughtExceptionHandler() 메서드 호출
    • 위의 두가지 경우가 모두 부착되어 있을 경우에는 특정 스레드마다 붙은 핸들러가 우선시되어 모든스레드에 부착된 핸들러는 호출되지 않는다.
  • 안드로이드 런타임은 앱이 시작될 때 전역 핸들러를 부착한다. 이 전역 핸들러의 기본동작은 잡히지 않은 예외가 발생했을 때, 프로세스를 죽이는 것으로 모든 스레드가 동등하게 처리된다.
  • Ex - 앱이 크래시되기 직전에 로그남기기
// 앱 시작시 실행되는 아무 클래스
public class MyApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate(0;
        //새로운 전역 핸들러를 설정
        Thread.setDefaultUncaughtExceptionHandler(new LogExceptionHandler());
    }
}

//새로 정의한 예외핸들러 클래스
public class LogExceptionHandler implements Thread.UncaughtExceptionHandler {
    private final Thread.UncaughtExceptionHandler defaultHandler;
    
    public LogExceptionHandler() {
        defaultHandler = Thread.getDefaultUncaughtExceptionHandler();
    }
    
    @Override
    public void uncaughtException(Thread thread, Throwable throwable) {
        //로그를 파일로 남기거나 서버로 전송
        
        //안드로이드 런타임이 붙였던 기존 핸들러로 작업 위임
        default.Handler.uncaughtException(thread, throwable);
    }
}

2.스레드 관리

스레드 정의(Define)와 시작

  • 스레드 정의 방법에 따라, 그 스레드의 생명주기가 다르다. 그래서 때때로 안드로이드의 컴포넌트(Activity, Service, BroadcastReceiver, ContentProvider)와 생명주기가 달라서 메모리 누수를 일으키기도 한다.

익명 내부클래스로 정의

  • 익명 내부클래스는 구현이 간단하지만, 외부클래스의 인스턴스에 대한 참조를 내부적으로 유지하고 있다.
public class AnyObject {
    //UI 스레드에서 호출되는 메서드
    @UiThread
    public void anyMethod() {
        new Thread() {
            @Override
            public void run() {
                // 긴 태스크를 실행한다고 가정
                // 해당 스레드가 살아있는 동안 이 스레드는 AnyObject 인스턴스의 참조를 유지하고 있다.
                doLongRunningTask();
            }
        }.start();
    }
}

공개된 독립 클래스로 정의

  • 스레드를 실행하는 인스턴스에 대한 잠재적인 참조를 유지하지는 않지만, 클래스의 개수가 많아진다.
class TestThread extends Thread {
    @Override
    public void run() {
        // 긴 태스크를 실행한다고 가정
        doLongRunningTask();
    }
}

public class AnyObject {
    //UI 스레드에서 호출되는 메서드
    private TestThread testThread;
    
    @UiThread
    public void anyMethod() {
        testThread = new TestThread();
        testThread.start();
    }
}

정적 내부 클래스로 정의

  • 외부 클래스의 클래스 객체에 대한 내부참조를 유지하고 있다. 그렇지만 클래스객체의 참조는 메모리 누수의 원인이 되지 않는다.
public class AnyObject {
    static class TestThread extends Thread {
        @Override
        public void run() {
            // 긴 태스크를 실행한다고 가정
            doLongRunningTask();
        }
    }

    private TestThread testThread;

    //UI 스레드에서 호출되는 메서드
    @UiThread
    public void anyMethod() {
        testThread = new TestThread();
        testThread.start();
    }
}

스레드 유지

  • Activity의 설정이 변경되면 기본적으로 Activity는 재시작되며 가지고있던 멤버변수들도 초기화된다. - 당연히 스레드도 초기화되어 새로운 객체로 생성되어 다시 시작된다.
  • 해당 증상을 방지하기 위해 Activity와 Fragment는 설정의 변경에도 객체를 유지할 수 있는 방법을 제공한다.

Activity에서 스레드 유지

  • pulbic Object onRetainNonConfigurationInstance()
    • 설정 변경이 일어나기 전에 플랫폼에 의해 호출되는 콜백메서드
    • 새로 생성되는 Activity 객체에 전달할 객체를 반환하도록 구현해야 한다.
  • public Object getLastNonConfigurationInstance()
    • 설정 변경이 이루어진 후, 새로 생성된 Activity 객체에서 호출하는 메서드
    • onRetainNonConfigurationInstance() 메서드에서 반환한 객체를 반환한다.
    • 설정 변경이 아닌 다른이유로 Activity가 재시작 될 경우 null을 반환한다.
  • 예제
public class TestActivity extends Activity {
    private static class TestThread extends Thread {
        @Override
        public void run() {
            //TODO::긴 작업
        }
    }

    private static TestThread thread;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout_activity_test);
        Object retainedObject = getLastNonConfigurationInstance();
        if (retainedObject != null) {
            thread = retainedObject;
        } else {
            thread = new TestThread();
            thread.start();
        }
    }
    
    @Override
    public Object onRetainNonConfigurationInstance() {
        if (thread != null && thread.isAlive()) {
            return thread;
        }
        return null;
    }
}

Fragment에서 스레드 유지

  • Fragment의 상태 유지요청 메서드인 setRetainInstance(true)를 이용하여 프레그먼트를 유지한다.
  • 예제
public class TestFragment extends Fragment {
    private static class TestThread extends Thread {
        @Override
        public void run() {
            //TODO::긴 작업
        }
    }

    private TestThread thread;
    
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        if (thread == null) {
            thread = new Thread();
            thread.start();
        }
        // 이 메서드만 설정해주면 프레그먼트는 엑티비티의 설정이 변경되는 동안 객체가 유지된다.
        setRetainInstance(true);
    }
}

public class TestActivity extends Activity {
    TestFragment fragment;
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout_activity_test);
        FragmentManager manager = getFragmentManager();
        fragment = manager.findFragmentByTag("TestFragment");
        if (fragment == null) {
            FragmentTransaction transaction = manager.beginTransaction();
            fragment = new Fragment();
            transaction.add(fragment, "TestFragment");
            transaction.commit();
           
        }
    }
}

2017년 10월 22일 일요일

[안드로이드] 스레드2 - 안드로이드에서의 스레드 기초

스레드 통신

파이프

특징

  • 자바에서 제공하는 java.io 패키지의 API. 블로킹 IO를 지원한다.
  • 같은 프로세스 내의 두 스레드간의 단방향 데이터 전송을 지원
    • 리눅스의 파이프 통신 : 프로세스간 통신
    • 자바의 파이프 통신 : 동일 프로세스내의 스레드간 통신
  • 일반적인 사용케이스 : 하나의 태스크에서 다른 태스크로 계속해서 데이터를 옮길 때
  • 데이터 전송 유형
    • Binary : PipedInputStream / PipedOutputStream
    • String : PipedReader / PipedWriter
  • 파이프의 수명
    • 연결설정(connect()) : 시작
    • 연결종료(close()) : 종료

예제

데이터 생산자(UI 스레드)

  • EditText로부터 글자를 입력받아서, 처리할 스레드로 전송
public class TestActivity extends Activity implements TextWatcher {
    private EditText editText;
    private PipedWriter writer;
    private TextHandlerThread workerThread;
    
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentVie(R.layout.activity_test);
        editText = (EditText) findViewById(R.id.edit);
        editText.addTextChangedListener(this);
        
        initializeConnection();
    }
    
    private void initializeConnection() {
        writer = new PipedWriter();
        workerThread = new TextHandlerThread();
        try {
            workerThread.connect(writer);
            workerThread.start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    @Override
    public void onDestroy() {
        super.onDestroy();
        
        workerThread.interrupt();
        try {
            writer.close();
            workerThread.disconnect();
        } catch (IOExcepton e) {
            e.printStackTrace();
        }
    }
    
    @Override
    public void beforeTextChanged(CharSequence s, int start, int count, int after) {
    }

    @Override
    public void onTextChanged(CharSequence s, int start, int before, int count) {
        //추가되는 문자만 처리
        try {
            if (count > before) {
                writer.write(s.subSequence(before, count).toString());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void afterTextChanged(Editable s) {
    }
}

데이터 소비자(Worker 스레드)

  • UI 스레드로부터 전달받은 글자를 처리
public class TextHandlerThread extends Thread {
    private PipedReader reader;
    
    public TextHandlerThread() {
        reader = new PipedReader();
    }
    
    public void connect(PipedWriter writer) throws IOException {
        writer.connect(reader);
    }
    
    public void disconnect() throws IOException {
        reader.close();
    }
    
    @Override
    public void run() {
        while (!Thread.currentThread().isInterrupted()) {
            try {
                int i;
                while ((i = reader.read()) != -1) {
                    char c = (char) i;
                    //TODO : 문자처리 로직 추가
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

공유메모리

  • 공유 메모리 : 같은 프로세스내의 모든 스레드가 접근할 수 있는 메모리 영역(Heap 영역)
    • 인스턴스 멤버변수
    • 스태틱 멤버변수
    • 객체
  • 공유메모리를 이용해 스레드간 데이터 Read/Write - 각 스레드간의 동기화 문제가 발생할 여지가 있다!
    • 시그널링을 통해 해결

시그널링

  • 시그널링 : 특정 스레드의 상태를 다른 스레드로 전파
  • notify() / signal() - 무작위로 하나의 메서드만 꺠움
  • notifyAll() / signalAll() - 기다리는 모든 스레드를 깨움
동기화타입synchronizedReentrantLockReentrantReadWriteLock
Block & WaitObject.wait()
Object.wait(timeout)
Condition.await()
Condition.await(timeout)
Condition.await()
Condition.await(timeout)
NotifyObject.notify()
Object.notifyAll()
Condition.signal()
Condition.signalAll()
Condition.signal()
Condition.signalAll()
  • 안드로이드의 UI스레드에서는 사용할 수 없다.
    • UI스레드가 block 상태로 지속되면, ANR 발생

블로킹 큐

  • java.util.concurrent.BlockingQueue 클래스 API
  • 저수준 메커니즘인 시그널링 기법을 추상화하여 만든 고수준 메커니즘
    • 스레드 시그널링 + 리스트구현 래핑
  • 생산자 - 소비자 패턴을 이용해 문제 해결
    • put() : 큐에 넣는 메서드. 큐가 가득차면 block
    • take() : 큐에서 빼는 메서드. 큐가 비면 block

메시지 전달

  • Non-Blocking 생산자 - 소비자 패턴 메커니즘
  • android.os 패키지의 API를 이용
    • Message : 데이터 / 태스크를 포함하는 단위. 스레드간 주고받는 주체
    • MessageQueue : 소비자 스레드에서 처리할 메시지들을 담고있는 무제한의 연결리스트. 루퍼 당 하나의 스레드만 연결될 수 있다.
    • Looper : 메시지 발송담당. 스레드 당 하나의 루퍼만 연결될 수 있다.
    • Handler : 생산자 스레드에서의 메시지 큐잉, 소비자 스레드에서의 메시지 처리를 담당.

Message

  • 스레드간 통신을 위해 주고받는 주체
  • 데이터 or 태스크 중 하나만을 옮기는 컨테이너 객체
    • 데이터 : 소비자 스레드에서 처리됨
    • 태스크 : 소비자 스레드에서 동작하는 태스크. 현재 진행중인 태스크가 없을 때 실행됨
  • 소비자 스레드에서 메시지의 처리
    • 데이터가 포함된 메시지 : Handler의 handleMessage(Message) 콜백메서드에서 수신된 데이터 메시지를 처리
    • 태스크가 포함된 메시지 : 스레드에서 자동적으로 태스크를 실행. handleMessage() 콜백메서드에서는 태스크 메시지를 수신하지 않는다.
Message 내부 필드
필드명자료형설명
whatint메시지의 식별자
arg1, arg2int정수값을 전달하는 경우에 사용되는 간단한 데이터 필드
objObject임의의 객체. 이 객체가 다른 프로세스의 스레드로 전달될 때는 반드시 Parcelable 로 구현해야 한다.
dataBundle임의의 데이터값을 넣는 컨테이너
replyToMessanger다른 프로세스의 핸들러 참조. 프로세스간 통신을 위해 존재한다.
callbackRunnable스레드에서 실행할 태스크. Handler의 postXXX() 메서드에서 보낸 Runnable 객체
Message 생명주기
  • 4가지의 상태가 존재.
  • 앱에서 메시지를 다룰 때, 메시지의 상태에 어떠한 가정도 하지 않아야 한다.
  • 일단 메시지가 메시지큐에 추가되면, 메시지 안의 내용은 변경되면 안된다.

MessageQueue

  • 처리될 메시지들로 구성된 무제한의 단방향 연결리스트
  • 스레드에서는 핸들러를 이용하여 메시지큐 처리
    • 생산자 스레드 : 메시지큐에 메시지 삽입
    • 소비자 스레드 : 메시지큐에서 메시지 추출하여 처리
  • 메시지는 타임스탬프를 기준으로 정렬된다.
    • 가장 낮은 타임스탬프값을 가진 메시지가 맨 앞에 놓인다.(가장 빨리 처리된다.)
    • 현재시간보다 타임스탬프값이 작을 때만 해당 메시지를 소비자 스레드로 전달한다. 현재시간보다 타임스탬프값이 크다면(미래의 메시지), 해당 시각이 될 때까지 기다린 후 메시지를 전달한다.

Looper

  • 메시지큐에 있는 메시지를 정확한 핸들러로 보내는 역할을 담당
  • 소비자 스레드에서는 메시지큐에 직접접근을 하지 않고, 루퍼를 통해 메시지를 얻는다.
  • 루퍼는 스레드당 하나만 연결된다.
    • 이미 스레드와 연결된 루퍼를 다른스레드에 다시 연결하려고 하면 RuntimeException을 던진다.
    • 결과적으로, 스레드는 하나의 메시지큐만 가지는 것이 된다.
  • UI스레드를 제외한 모든 스레드는 메시지처리를 하기 위해서 명시적으로 루퍼를 얻어야 하고, 메시지 처리를 끝내려는 스레드는 명시적으로 루퍼를 종료해주어야 한다.
Looper 연결
public class ConsumerThread extends Thread {
    @Override
    public void run() {
        Looper.prepare();
        
        //TODO : 루퍼와 핸들러 연결
        
        Looper.loop();
    }
}
  • Looper.prepare() : 루퍼를 생성하고, 루퍼와 현재 스레드를 연결한다. 아직 이 단계에서 메시지를 전송하지는 않는다.
  • Looper.loop() : run()메서드가 완료되지 않았음을 보장하는 Blocking 메서드. run()메서드가 차단된 동안, 루퍼는 이 스레드로 메시지를 전달한다.
Looper 종료
  • quit() / quitSafely() 메서드
    • quit() : 현재시각보다 낮은 타임스탬프의 메시지를 포함하여, 모든 대기중인 메시지를 폐기
    • quitSafely() : 현재시각보다 낮은 타임스탬프의 메시지는 제외하고, 높은 타임스탬프의 대기메시지들을 폐기. 남은 메시지들은 루퍼가 종료되기 전에 처리된다. API레벨 18에서 추가된 메서드.
  • 루퍼를 종료한다고 스레드가 종료되지는 않는다. 단지, blocking 중이었던 loop() 메서드를 빠져나오는 것이다.
UI스레드의 루퍼
  • UI스레드는 앱이 초기화될 때 기본적으로 루퍼를 연결하기 때문에, 따로 연결할 필요가 없다.
  • UI스레드 루퍼는 종료시킬 수 없다. quit() / quitSafely() 메서드가 호출되면 RuntimeException을 던진다.
  • UI스레드 루퍼를 다른 스레드에 부착할 수 없다.
  • Looper.getMainLooper() 메서드를 이용하면 어디서든 UI스레드 루퍼를 접근할 수 있다.

Handler

  • 스레드에서 메시지 삽입/처리를 직접적으로 담당.
  • 핸들러는 내부적으로 메시지큐와의 상호작용을 하기위해 루퍼를 이용한다. 그러므로, 핸들러를 이용하는 스레드는 반드시 루퍼를 연결해야 한다.
Handler 생성
  • 생성시점에 루퍼와 바인딩된다. 루퍼와의 바인딩에 실패하면 RuntimeException을 던진다.
  • 한번 바인딩된 루퍼는 변경될 수 없다.
// 현재 스레드의 루퍼와 바인딩하는 생성자
new Handler();
new Handler(Handler.Callback);

//명시적으로 선언된 루퍼와 바인딩하는 생성자
new Handler(Looper);
new Handler(Looper, Handler.Callback);
메시지 삽입
//데이터 메시지 (sendXXX())
//메시지 객체 직접 전달
boolean sendMessage(Message msg)
boolean sendMessageAtFirstOfQueue(Message msg)
boolean sendMessageAtTime(Message msg, long uptimeMillis)
boolean sendMessageDelayed(Message msg, long delayMillis)
//메시지 의도만 전달
boolean sendEmptyMessage(int what)
boolean sendEmptyMessageAtTime(int what, long uptimeMillis)
boolean sendEmptyMessageDelayed(int what, long delayMillis)

//태스크 메시지 (postXXX())
boolean post(Runnable r)
boolean postAtFrontOfQueue(Runnable r)
boolean postAtTime(Runnable r, Object token, long uptimeMillis)
boolean postAtTime(Runnable r, long uptimeMillis)
boolean postDelayed(Runnable r, long delayMillis)
  • 메시지 전달순서 조절 - 앱이 유일하게 핸들링할 수 있는 방법이다.
    • 메시지의 처리시간은 불확정이다 - 기존에 처리중인 메시지 / 운영체제의 스케쥴링에 영향을 받기 때문
    • default : 전달이 즉시 가능
    • at_front : 타임스탬프값 0으로 전달되어, 다른메시지가 끼어들지 않는 한. 다음에 전달될 메시지가 된다.
    • delay : 이 지연시간 후에 메시지가 전달될 수 있다.
    • uptime : 이 절대시간에 메시지가 전달될 수 있다.
메시지 처리
  • 태스크 메시지
    • 따로 핸들링할 필요 없음. 전송된 태스크 Runnable의 run 메서드가 자동적으로 실행된다.
  • 데이터 메시지
    • 소비자 스레드에서 Handler.handleMessage(Message) 메서드를 오버라이드 하여 받은 메시지를 처리한다.
    • 소비자 스레드에서 Handler에 콜백 인터페이스를 등록한다.
//Handler.handlerMessage() 오버라이드
public class ConsumerThread extends Thread {
    public Handler handler;
    @Override
    public void run() {
        Looper.prapare();
        // 핸들러는 반드시 Looper가 설정된 다음에 생성해야 한다!!
        handler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                //메시지 처리
            }
        };
        Looper.loop();
    }
}

//Handler에 콜백 인터페이스 등록
public class ConsumerThread extends Thread implements Handler.Callback {
    public Handler handler;
    @Override
    public void run() {
        Looper.prapare();
        // 핸들러는 반드시 Looper가 설정된 다음에 생성해야 한다!!
        handler = new Handler(this);
        Looper.loop();
    }
    
    @Override
    public boolean handleMessage(Message msg) {
        //메시지 처리
        //더이상 처리할 메시지가 없을때 true 리턴. false를 리턴하면 Handler.handleMessage() 메서드가 이어서 호출된다.
        return true;
    }
}
메시지 제거
  • Handler의 메서드를 이용하면 큐에 넣어진 메시지를 제거할 수 있다.
    • 단, 메시지가 루퍼에 의해 큐에서 꺼내지기 전에만 가능하다.
    • 메시지를 정확하게 식별할 수 있어야 한다.
식별자 타입설명적용되는 메시지 타입
Handler메시지 수신자태스크 & 데이터 메시지
Object메시지 태그태스크 & 데이터 메시지
int메시지의 what 매개변수데이터 메시지
Runnable실행될 태스크태스크 메시지
// 메시지 큐에서 태스크 제거
void removeCallbacks(Runnable r)
void removeCallbacks(Runnable, Object token)

//메시지 큐에서 데이터 제거
void removeMessages(int what)
void removeMessages(int what, Object object)

//메시지 큐에서 태스크 / 데이터 동시에 제거(Object로 식별할 경우만 가능)
void removeCallbakcsAndMessages(Object token)