안드로이드 면접준비 - handler

기본 정보
1. Handler-컨트롤러
2. Looper- 폴링
3. 메시지 객체
4.MessageQueue-단일 체인 테이블 구조의 메시지 대기열
한 소식의 전생 현세
일반적인 상황에서 비동기적인 조작과 관련된 경우handler를 도입하여 비동기적인 조작의 결과를 받아들여 UI 정보를 업데이트해야 한다.그래서 일반적인 조작은 이렇습니다.
그림 참조
https://zhuanlan.zhihu.com/p/25222485

private Handler handler = new Handler(){
    @Override
    public void handleMessage(Message msg) {
         super.handleMessage(msg);
         textView.setText(" UI    ");
    }
};
@Override
protected void onCreate(Bundle savedInstanceState){
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_main);
       textView = (TextView) findViewById(R.id.mytv);
       new Thread(new Runnable() {
           @Override
           public void run() {
               //      
               SystemClock.sleep(3000);
               handler.sendMessage(new Message());
           }
       }).start();

   }

우선handler를 만듭니다
두 번째 Thread 생성
Thread에서 어떤 조작을 처리한 후handler를 통해sendMessage(msg)는 비동기적인 결과를 메시지 대기열MessageQueue에 전송합니다.
그런 다음 handlerMessage () 를 복사해서 이 작업을 완성합니다.
문제.
Looper는요?MessageQueue는요?
이게 도대체 어떻게 연관된 거야.
그림https://zhuanlan.zhihu.com/p/25222485

public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
    MessageQueue queue = mQueue;
    if (queue == null) {
        RuntimeException e = new RuntimeException(
                this + " sendMessageAtTime() called with no mQueue");
        Log.w("Looper", e.getMessage(), e);
        return false;
    }
    return enqueueMessage(queue, msg, uptimeMillis);
}

MessageQueue가 비어 있는지 여부를 판단합니다. 비어 있지 않은지 확인하십시오.

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        msg.target = this;
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
    }

중요한 장면

boolean enqueueMessage(Message msg, long when) {
        if (msg.target == null) {
            throw new IllegalArgumentException("Message must have a target.");
        }
        if (msg.isInUse()) {
            throw new IllegalStateException(msg + " This message is already in use.");
        }

        synchronized (this) {
            if (mQuitting) {
                IllegalStateException e = new IllegalStateException(
                        msg.target + " sending message to a Handler on a dead thread");
                Log.w(TAG, e.getMessage(), e);
                msg.recycle();
                return false;
            }

            msg.markInUse();
            msg.when = when;
            Message p = mMessages;
            boolean needWake;
            if (p == null || when == 0 || when < p.when) {
                // New head, wake up the event queue if blocked.
                msg.next = p;
                mMessages = msg;
                needWake = mBlocked;
            } else {
                // Inserted within the middle of the queue.  Usually we don't have to wake
                // up the event queue unless there is a barrier at the head of the queue
                // and the message is the earliest asynchronous message in the queue.
                needWake = mBlocked && p.target == null && msg.isAsynchronous();
                Message prev;
                for (;;) {
                    prev = p;
                    p = p.next;
                    if (p == null || when < p.when) {
                        break;
                    }
                    if (needWake && p.isAsynchronous()) {
                        needWake = false;
                    }
                }
                msg.next = p; // invariant: p == prev.next
                prev.next = msg;
            }

            // We can assume mPtr != 0 because mQuitting is false.
            if (needWake) {
                nativeWake(mPtr);
            }
        }
        return true;
    }

메시지 중에 재밌는 거 몇 개.
 Handler target;  Message next;     public static Message obtain(Handler h) {         Message m = obtain();         m.target = h;         return m;     }
target을 중점적으로 표시하면 니마: 메시지는 만들 때handler와 연결되어 있습니다.
Looper 정보

public static void prepare() {
        prepare(true);
    }

    private static void prepare(boolean quitAllowed) {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper(quitAllowed));
    }

ThreadLocal에 중점을 두고,
이것은 어떤 종류입니까?
static final ThreadLocal sThreadLocal = new ThreadLocal();
ThreadLocal은 스레드 변수를 저장하는 데 사용됩니다. 같은 static ThreadLocal에 대해 서로 다른 스레드는 get, set,remove 자신의 변수만 저장할 수 있고 다른 스레드의 변수는 영향을 주지 않습니다.
1、ThreadLocal.get: ThreadLocal에서 현재 스레드 변수의 값을 가져옵니다.
2、ThreadLocal.set: ThreadLocal에서 현재 스레드 변수의 값을 설정합니다.
3、ThreadLocal.remove: ThreadLocal에서 현재 스레드 변수의 값을 제거합니다.
4、ThreadLocal.initialValue: ThreadLocal이 현재 라인에 값을 부여하지 않았을 때나 현재 라인이remove 방법을 호출한 후에 get 방법을 호출하고 이 방법 값을 되돌려줍니다.
이건 너무 중요해.이게 무슨 꼬챙이야?
ThreadLocal은 각 스레드의 Looper를 저장하고 Looper에는 MessageQueue, Looper의 구조기 private Looper(boolean quit Allowed) {mQueue = new MessageQueue(quit Allowed), mThread = Thread.current Thread(),    }
sendMsg에서 한 번 보내면 ThreadLocal에서 set을 한 번 보냅니다.
Looper에서 loop 방법은 사순환입니다. (주 라인에서의 사순환은 왜 ANR을 일으키지 않았습니까?)

for (;;) {
            Message msg = queue.next(); // might block
            if (msg == null) {
                // No message indicates that the message queue is quitting.
                return;
            }
            //......
            try {
                msg.target.dispatchMessage(msg);
            } finally {
                if (traceTag != 0) {
                    Trace.traceEnd(traceTag);
                }
            }
            //......
            msg.recycleUnchecked();
        }

야하, 누가 오염되고, 누가 관리하고, 누가 발송하고, 누가 처리하는가
public void dispatchMessage(Message msg) {         if (msg.callback != null) {             handleCallback(msg);         } else {             if (mCallback != null) {                 if (mCallback.handleMessage(msg)) {                     return;                 }             }             handleMessage(msg);         }     }
끝:handler 소식을 듣고 부끄러움도 거친 생활을 하게 되었다