Fun Handler and fun Handler

Fun Handler and fun Handler
 

Let's take a look at a simple message first.

1. privateProgressBar mProgressBar;
2. privateint i =0;
3. PrivateHandler mHandler = newHandler () {// create a Handle
4. @Override
5. publicvoid handleMessage(Message msg){
6. super.handleMessage(msg);
7. Log.i("-mHandler->",i+"");
8. mProgressBar.setProgress(i);
9. }
10. };
11. privateRunnable runnable =newRunnable(){
12. @Override
13. publicvoid run(){
14. Log.i("-Runnable->",i+"");
15. i +=10;
16. // The task to be done. Call this Runnable object again to implement the timer operation every two seconds.
17. MHandler. postDelayed (runnable, 2000); // Timer
18. MHandler. sendMessageDelayed (Message. obtain (), 0); // send a Message to trigger the override handleMessage Method
19. }
20. };
22. @Override
23. protectedvoid onCreate(@NullableBundle savedInstanceState){
24. super.onCreate(savedInstanceState);
25. setContentView(R.layout.activity_handler);
26. mProgressBar =(ProgressBar) findViewById(R.id.pb_handler);
27. MHandler. post (runnable); // start the execution thread
28. // Runnable. run (); // you can use this to start a thread.
29. }
31. /**
32. * Stop the thread operation during deletion.
33. */
34. @Override
35. protectedvoid onDestroy(){
36. super.onDestroy();
37. mHandler.removeCallbacks(runnable);
38. }
39. }

 

Two methods for obtaining Message

1. // Two methods for obtaining Message
2. // Returns a new Message from the global message pool.
3. MHandler. obtainMessage () and Message. obtain ()

1. // The two methods are actually the same, but one is obtained through Handler and the other is obtained through the static method of Message. When you query the Handler source code, you will find that the obtainMessage method is composed:
2. publicfinalMessage obtainMessage()
3. {
4. returnMessage.obtain(this);
5. }

After querying the source code, it is found that the Message provides the following variables:

1. Message recycleUnchecked () method
2. void recycleUnchecked(){
3. // Mark the message as in use while it remains in the recycled object pool.
4. // Clear out all other details.
5. flags = FLAG_IN_USE; //int
6. what =0; // int
7. arg1 =0; // int
8. arg2 =0; // int
9. obj =null; // Object
10. ReplyTo = null; // Messenger, Messenger
11. sendingUid =-1;
12. when =0; // long
13. target =null; // Handler
14. callback =null; // Runable
15. data =null; // Bundle
17. synchronized(sPoolSync){
18. if(sPoolSize < MAX_POOL_SIZE){
19. next = sPool;
20. sPool =this;
21. sPoolSize++;
22. }
23. }
24. }

The advantage of using system variables is that the consumption of the system can be greatly reduced. Therefore, the code for updating the progress bar should be modified

1. mProgressBar.setProgress(msg.arg1);

1. privateRunnable runnable =newRunnable(){
2. @Override
3. publicvoid run(){
4. Log.i("-Runnable->", i +"");
5. i +=3;
6. // The task to be done. Call this Runnable object again to implement the timer operation every two seconds.
7. mHandler.postDelayed(runnable,300);
8. Message msg = mHandler.obtainMessage();
9. msg.arg1 +=i;
10. MHandler. sendMessage (msg); // The handleMessage method that will be overwritten only when a message is sent
11. // MHandler. sendMessageDelayed (Message. obtain (), 0); // The handleMessage method to be rewritten is triggered when a Message is sent.
12. }
13. };

 

Handler optimized

1. privateHandler mHandler =newHandler(){
2. @Override
3. publicvoid handleMessage(Message msg){
4. super.handleMessage(msg);
5. //Log.i("-mHandler->", i + "");
6. if(msg.arg1 >100){
7. mHandler.removeCallbacks(runnable);
8. }else{
9. mProgressBar.setProgress(msg.arg1);
10. }
11. }
12. };

 

From Weizhi note (Wiz)