Handler is often used in our daily development. It is mainly used to process asynchronous messages. When a message is sent, it first enters a message queue, and the function that sends the message can return.
Although it is often used, using it in the wrong way can cause some problems. Let’s look at some of the Handler related issues and resolve them
Handler causes memory leakage
Andorid typically executes time-consuming business logic in child threads, and then sends a message from the Handler to the main thread to update the UI.
When we create a Handler using an inner class or an anonymous inner class, it implicitly holds a reference to an external object, typically an Activity. If we shut down the Activity while it’s still running, the thread holds a reference to the Handler, The handler holds a reference to the Activity, causing the Activity to be unable to be reclaimed and thus causing a memory leak.
Also, if we had used the handler.postdelayed () method, which would have encapsulated the handler as a Message object and placed the Message object on the MessageQueue queue, there would have been a chain of references held until the delay was reached: MessageQueue – > Message – > Hanlder – > Activity. As a result, the Activity cannot be reclaimed, causing a memory leak
Solutions:
- Stop the thread in the Activity’s onDestroy method and empty the Handler directly. Check whether the Hanlder is empty before executing the following logic
- By setting Hanlder as a static object, Java static classes do not hold references to external classes, and the Activity can be reclaimed. The Handler can’t update the UI because it doesn’t hold a reference to the Activity. You need to pass the Activity into the Handler, which uses weak references to store the Activity to ensure that it can be recycled.
Why can’t you just create an empty constructor Handler in a child thread
New Handler() is an error in a child thread
java.lang.RuntimeException: Can't create handler inside thread[Thread..] that has not called Looper.prepare()Copy the codeWhy is that? We can follow up the code and take a look
public Handler() {
this(null, false);
}
public Handler(Callback callback, boolean async) {
....
mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread " + Thread.currentThread()
+ " that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
Copy the codeMyLooper () this method returns null. Why is it null
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
Copy the codeSo you can see that it’s going to fetch this looper from a ThreadLocal, ThreadLocal is like a Map, the key is the current thread, the value is looper, New a Handler directly from the child thread. If the thread has no object looper in the ThreadLocal, an error is reported
The main thread already has a looper object in it. We know that the Activity’s main function is in the ActivityThread class. We see this statement in the ActivityThread main method
Looper.prepareMainLooper();
public static void prepareMainLooper() {
prepare(false);
synchronized (Looper.class) {
if(sMainLooper ! = null) { throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}
}
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));
}
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if(map ! = null) map.set(this, value);else
createMap(t, value);
}
Copy the codeAs you can see, the prepare method places Looper in ThreadLocal, where the key is the current thread
We can pass a Looper to Hanlder to prevent errors such as new Handler(looper.getMainLooper ()); Or call looper.prepare () before the new Handler;
Does textView.settext () execute only in the main thread?
Textview.settext () is a function of a new Thread called in the run method of a Thread, and it succeeds without error.
When our setText refreshes the layout, it executes the checkForRelayout() method, which finally executes the requestLayout() and invalidate() methods to request a new layout and redraw, If you follow these two methods, you’ll end up in requestLayout() of the ViewRootImpl class, which contains a checkThread() method.
private void checkForRelayout() {... requestLayout(); invalidate(); } // requestLayout() public voidrequestLayout() {... //mParent is ViewRootImplif(mParent ! = null && ! mParent.isLayoutRequested()) { mParent.requestLayout(); }... } // requestLayout in ViewRootImpl @override public voidrequestLayout() {
if(! mHandlingLayoutInLayoutRequest) { checkThread(); mLayoutRequested =true;
scheduleTraversals();
}
}
void checkThread() {
if(mThread ! = Thread.currentThread()) { throw new CalledFromWrongThreadException("Only the original thread that created a view hierarchy can touch its views."); }}Copy the codeCheckThread () checks whether the current thread is the main thread, and raises this exception if it is not.
Why does setText() not throw this exception? MThread is assigned in the constructor of ViewRootImpl, which is created after the Activity object has been created. RequestLayout () checks to see if ViewRootImpl is null before it is called.
If the setText() method is fast enough to refresh the ViewRootImpl before it is created, no errors will be reported.
final void handleResumeActivity(IBinder token,
boolean clearHide, boolean isForward, boolean reallyResume, int seq, String reason) {
...
ViewRootImpl impl = decor.getViewRootImpl();
if (impl != null) {
impl.notifyChildRebuilt();
}
...
}
Copy the codeSo if we execute our setText faster than we create ViewRootImpl, we won’t execute the thread check method. It will draw successfully
What’s the difference between the two ways of writing new Handler()?
Two kinds of writing
Handler mHandler1 = new Handler(new Handler.Callback() {
@Override
public boolean handleMessage(Message msg) {
return false; }});Copy the codeHandler mHandler2 = new Handler(){ @Override public void handleMessage(Message msg) { super.handleMessage(msg); }};Copy the codeIf you write these two methods in AndroidStudio, you will see a yellow warning for the second method, so I recommend the first method. In the dispatchMessage method of the Hanlder
public void dispatchMessage(Message msg) {
if(msg.callback ! = null) { handleCallback(msg); }else {
if(mCallback ! = null) {if (mCallback.handleMessage(msg)) {
return; } } handleMessage(msg); }}Copy the codeMSG. Callback is a Runnable, and the handleCallback(MSG) method is the run method that executes it. If the mCallback is not null, its handleMessage method is executed. This mCallback is the Callback passed by the first method. HandleMessage’s own methods are executed only when neither of the previous cases is true.
The second method is equivalent to creating a subclass of Handler and implementing the handleMessage method of the parent class. The first method is equivalent to creating a Handler object and passing in a callback.
The principle of ThreadLocal
public class ThreadLocal<T> {...... }Copy the codeThreadLocal is a local line utility class that maps a private thread to its replica object. Variables between threads do not interfere with each other. In high concurrency scenarios, stateless calls can be implemented
A ThreadLocal is a Map whose key is the current thread, whose value is T, and we can specify any type to hold it.
public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if(map ! = null) { ThreadLocalMap.Entry e = map.getEntry(this);if(e ! = null) { @SuppressWarnings("unchecked")
T result = (T)e.value;
returnresult; }}return setInitialValue();
}
Copy the codeGet () : ThreadLocalMap<ThreadLocal, Object> from ThreadLocalMap; If not, call the setInitialValue() method.
private T setInitialValue() {
T value = initialValue();
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if(map ! = null) map.set(this, value);else
createMap(t, value);
return value;
}
Copy the codeThe initialValue method returns null by default. You can subclass the object that you want to save.
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if(map ! = null) map.set(this, value);else
createMap(t, value);
}
Copy the codeThe set method also takes ThreadLocalMap<ThreadLocal, Object> from the current thread and stores the value into ThreadLocalMap. Create one if ThreadLocalMap is empty
Handler source code analysis
Handler Looper Message MessageQueue Handler Looper Message MessageQueue
(1) Create main thread Looper
Looper.prepareMainLooper();
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
public static void prepareMainLooper() {
prepare(false);
synchronized (Looper.class) {
if(sMainLooper ! = null) { throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}
}
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));
}
Copy the codePrepareMainLooper, a static Looer method, is called from the Main method of the ActivityThread class, creating a Looper and storing it in a ThreadLocal. You’ve already seen that each thread has its own ThreadLocal that holds its own private variables, in which case the ActivityThread is the main thread.
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
Copy the codeWhen Looper is created, a private message queue is created
(2) Create Handler
Handler handler = new Handler(){ @Override public void handleMessage(Message msg) { super.handleMessage(msg); }};Copy the codeNow that we’re pretty familiar with this step, handling messages in handleMessage, let’s look at the Handler constructor
public Handler() {
this(null, false);
}
public Handler(Callback callback, boolean async) {
......
mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread " + Thread.currentThread()
+ " that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
Copy the codeTake the current thread’s Looper object, assign the message queue in Looper to its member variable mQueue, and copy the callback object mCallback if passed in.
(3) Send messages
There are several methods for sending messages: sendMessage, sendEmptyMessage, sendEmptyMessageDelayed, sendMessageAtTime, etc., all of which eventually go into the following method to call enqueueMessage
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);
}
Copy the codeEnqueueMessage indicates that messages are queued, and mQueue is the queue retrieved from Looper
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
Copy the codeThis assigns itself, the Hanlder, to the target in the Message, and then calls the method that processes the Message through a reference to this Handler. The enqueue method of the MessageQueue MessageQueue is then called
boolean enqueueMessage(Message msg, long 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 {
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; }... }Copy the codeAs you can see, Message is a list structure, where the Message is placed in the next of the list.
(4) Consumption news
Return to the main method of ActivityThread after calling looper.prepareMainLooper (); Looper.loop() is then called; methods
public static void loop() {
final Looper me = myLooper();
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
final MessageQueue queue = me.mQueue;
// Make sure the identity of this thread is that of the local process,
// and keep track of what that identity token actually is.
Binder.clearCallingIdentity();
final long ident = Binder.clearCallingIdentity();
for (;;) {
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
// This must be in a local variable, in case a UI event sets the logger
final Printer logging = me.mLogging;
if(logging ! = null) { logging.println(">>>>> Dispatching to " + msg.target + "" +
msg.callback + ":" + msg.what);
}
final long slowDispatchThresholdMs = me.mSlowDispatchThresholdMs;
final long traceTag = me.mTraceTag;
if(traceTag ! = 0 && Trace.isTagEnabled(traceTag)) { Trace.traceBegin(traceTag, msg.target.getTraceName(msg)); } final long start = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis(); final long end; try { msg.target.dispatchMessage(msg); end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis(); } finally {if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
if (slowDispatchThresholdMs > 0) {
final long time = end - start;
if (time > slowDispatchThresholdMs) {
Slog.w(TAG, "Dispatch took " + time + "ms on "
+ Thread.currentThread().getName() + ", h=" +
msg.target + " cb=" + msg.callback + " msg="+ msg.what); }}if(logging ! = null) { logging.println("<<<<< Finished to " + msg.target + "" + msg.callback);
}
// Make sure that during the course of dispatching the
// identity of the thread wasn't corrupted. final long newIdent = Binder.clearCallingIdentity(); if (ident ! = newIdent) { Log.wtf(TAG, "Thread identity changed from 0x" + Long.toHexString(ident) + " to 0x" + Long.toHexString(newIdent) + " while dispatching to " + msg.target.getClass().getName() + " " + msg.callback + " what=" + msg.what); } msg.recycleUnchecked(); }}Copy the codeIn the above code, get the current thread’s Looper, then get the Message queue in the Looper, and then start an infinite loop by saying Message MSG = queue.next(); Constantly take out the message and then call MSG. Target. DispatchMessage (MSG); Method to process messages.
MSG. Target is the Handler object. So we’re calling the dispatchMessage method in this Handler
public void dispatchMessage(Message msg) {
if(msg.callback ! = null) { handleCallback(msg); }else {
if(mCallback ! = null) {if (mCallback.handleMessage(msg)) {
return; } } handleMessage(msg); }}Copy the codeThere are three ways to handle messages, the second and third of which correspond to the two ways to create handlers at the beginning of this article. The first MSG. Callback is a Runnable object
handler.post(new Runnable() {
@Override
public void run() {
}
})
public final boolean post(Runnable r) {
return sendMessageDelayed(getPostMessage(r), 0);
}
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}
Copy the codeWhen we call handler.post(), we pass in a Runnable object, which is the Runnable we passed in.
OK, the process analysis of Handler is complete.
Handwritten Handler exercises
Handler Handler Handler Handler Handler Handler Handler Handler Handler Handler Handler Handler Handler
According to the previous analysis, we can know here involves a few classes, ActivityThread, Message, MessageQueue, Handler, stars.
The main method of the ActivityThread class completes after the Activity starts
So we create an ActivityThread directly under the project’s Test folder to simulate the entry to the Activity.
public class ActivityThread {
@Test
public void main(){// prepare looper looper. PrepareMainLooper (); // Create Handler final Handler Handler = newHandler(){ @Override public void handleMessage(Message msg) { super.handleMessage(msg); Println (msg.obj.tostring ()); }}; // Start a thread to send a message new from a child threadThread(){
@Override
public void run() { super.run(); MSG = new Message(); msg.obj ="Hello Handler"; handler.sendMessage(msg); } }.start(); // Open looper.loop (); }}Copy the codeIt is easy to follow the four steps described above: (1) prepare the Looper, (2) create a Handler to override the handleMessage method to process the message, (3) send the message, and (4) start a loop to process the message.
The Message class:
public class Message { public int what; public Handler target; /** * public Object obj; @Override public StringtoString() {
returnobj.toString(); }}Copy the codeMessageQueue class, simulated using a blocking queue, ArrayBlockingQueue.
public class MessageQueue { private ArrayBlockingQueue<Message> mMessages = new ArrayBlockingQueue<Message>(50); Public void enqueueMessage(Message MSG) {try {mmessages.put (MSG); } catch (InterruptedException e) { e.printStackTrace(); }} // Fetch Message public Messagenext() {
try {
return mMessages.take();
} catch (InterruptedException e) {
e.printStackTrace();
}
returnnull; }}Copy the codeWhich class
public class Looper {
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
MessageQueue mQueue;
public Looper() {
mQueue = new MessageQueue();
}
public static void prepareMainLooper() {
prepare();
}
private static void prepare() {
if(sThreadLocal.get() ! = null) { throw new RuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper());
}
public static Looper myLooper() {
returnsThreadLocal.get(); } // Start the loop public static voidloop() {
Looper me = myLooper();
MessageQueue queue = me.mQueue;
while (true){
Message msg = queue.next();
if(msg! =null){if(msg.target! =null){ msg.target.dispatchMessage(msg); } } } } }Copy the codeOK, run the code directly in the ActivityThread test class and you can see Hello Handler successfully printed in the log!
The last
If you see this and you think it’s good, give it a thumbs up? If you think there is something worth improving, please leave a message. Will inquire seriously, correct inadequacy. thank you
The reason why someone is better than you is because they are already better and are constantly trying to become better, while you are still satisfied with the status quo and secretly happy! I hope you can click a like and pay attention to me, I will update the technical dry goods in the future, thank you for your support!
Forward + like + attention, the first time to get the latest knowledge
The road to being an Android architect is a long one.