Android handler

1.Handler类引入原因

Android 里多个线程并发的操作UI组件，会导致线程安全问题的出现
Android解决方案：规定只允许在UI线程中修改Activity中的UI组件
UI线程：App第一次启动时，Android会同时启动一条UI线程(主线程)，负责处理与UI相关的事件，如触发事件，修改UI组件等
如果想让新启动的线程周期性的修改UI组件的属性值

使用Handler类

2.名词解析

UI线程：主线程，系统创建UI线程时，初始化一个Looper对象，同时传建一个与其关联的MessageQueue
Handler：发送与处理消息，当前线程中有一个Looper对象，Handler才能正常工作
Message：Handler接受与处理消息的对象
MessageQueue：消息队列，先进先出管理Message，初始化Looper对象时会创建一个与其关联的MessageQueue Looper：管理MessageQueue，不断地从中取出Message分发给对应的Handler处理，每个线程只有一个Looper

总结：

子线程想要修改Activity中UI组件
创建一个Handler对象，通过该对象向主线程发送消息
发送的消息进入主线程的MessageQueue进行等待
Looper将按先入先出顺序取出，再根据message对象的what属性分发给对应的、Handler处理

3.Handler的相关方法

方法名	功能
void handlerMessage(Message msg)	处理消息的方法，通常用于被重写
sendEmptyMessage(int what)	发送仅包含what值的消息
sendEmptyMessageDelayed(int what, long delayMillis)	在指定的时间过后，发送一个只包含what值的消息
sendMessage(Message msg)	sep1将一个消息推入消息队列，在所有等待消息之后的末尾。sep2当前时间之前的，将被handleMessage接受。sep3在这个线程中附加到这个handle上
sendMessageDelayed(Message msg)	延迟一段时间发送消息，上面的step1、2、3也差不多
final boolean hasMessage(int what)	检查在消息队列中，是否有带what的待发送消息

3.Handler示例

1) Handler写在主线程中

主线程中
系统已经初始化了一个Looper对象
可直接创建Handler对象,进行信息的发送与处理

效果图:

示例代码

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"  
    xmlns:tools="http://schemas.android.com/tools"  
    android:id="@+id/RelativeLayout1"  
    android:layout_width="match_parent"  
    android:layout_height="match_parent"  
    android:gravity="center"  
    tools:context="com.jay.example.handlerdemo1.MainActivity" >  
  
    <ImageView  
        android:id="@+id/imgchange"  
        android:layout_width="wrap_content"  
        android:layout_height="wrap_content"  
        android:layout_alignParentLeft="true"  
        android:layout_alignParentTop="true" />  
  
</RelativeLayout>

MainActivity.java：

public class MainActivity extends Activity {  
  
    //定义切换的图片的数组id  
    int imgids[] = new int[]{  
        R.drawable.s_1, R.drawable.s_2,R.drawable.s_3,  
        R.drawable.s_4,R.drawable.s_5,R.drawable.s_6,  
        R.drawable.s_7,R.drawable.s_8  
    };  
    int imgstart = 0;  
      
    final Handler myHandler = new Handler()  
    {  
      @Override  
      //重写handleMessage方法,根据msg中what的值判断是否执行后续操作  
      public void handleMessage(Message msg) {  
        if(msg.what == 0x123)  
           {  
            imgchange.setImageResource(imgids[imgstart++ % 8]);  
           }  
        }  
    };  
    
      
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
        final ImageView imgchange = (ImageView) findViewById(R.id.imgchange);  
         
        //使用定时器,每隔200毫秒让handler发送一个空信息  
        new Timer().schedule(new TimerTask() {            
            @Override  
            public void run() {  
                myHandler.sendEmptyMessage(0x123);  
                  
            }  
        }, 0,200);  
    }  
  
}

2) Handler写在子线程中

Handler写在子线程中
自行创建一个Looper对象，创建流程:

1. 调用Looper.prepare() 方法，为当前线程创建Looper对象,Looper的构造器会创建配套的MessageQueue。
2. 创建Handler对象,重写handleMessage( ) 方法，可以处理来自于其他线程的信息了。
3. 调用Looper.loop() 方法,启动Looper。

简化：

• 调用Looper.prepare()，创建Looper对象。
• 创建Handler对象，重写handleMessage()。
• 调用Looper.loop()，启动Looper。

使用示例： 输入一个数，计算后通过Toast输出在这个范围内的所有质数
实现代码

main.xml：

<LinearLayout  
    xmlns:android="http://schemas.android.com/apk/res/android"  
    android:layout_width="match_parent"  
    android:layout_height="match_parent"  
    android:orientation="vertical">  
    <EditText  
        android:id="@+id/etNum"  
        android:inputType="number"  
        android:layout_width="match_parent"  
        android:layout_height="wrap_content"  
        android:hint="请输入上限"/>  
    <Button  
        android:layout_width="match_parent"  
        android:layout_height="wrap_content"  
        android:onClick="cal"  
        android:text="计算"/>    
</LinearLayout>

MainActivity.java:

public class CalPrime extends Activity  
{  
    static final String UPPER_NUM = "upper";  
    EditText etNum;  
    CalThread calThread;  
    // 定义一个线程类  
    class CalThread extends Thread  
    {  
        public Handler mHandler;  
  
        public void run()  
        {  
            Looper.prepare();  
            mHandler = new Handler()  
            {  
                // 定义处理消息的方法  
                @Override  
                public void handleMessage(Message msg)  
                {  
                    if(msg.what == 0x123)  
                    {  
                        int upper = msg.getData().getInt(UPPER_NUM);  
                        List<Integer> nums = new ArrayList<Integer>();  
                        // 计算从2开始、到upper的所有质数  
                        outer:  
                        for (int i = 2 ; i <= upper ; i++)  
                        {  
                            // 用i处于从2开始、到i的平方根的所有数  
                            for (int j = 2 ; j <= Math.sqrt(i) ; j++)  
                            {  
                                // 如果可以整除，表明这个数不是质数  
                                if(i != 2 && i % j == 0)  
                                {  
                                    continue outer;  
                                }  
                            }  
                            nums.add(i);  
                        }  
                        // 使用Toast显示统计出来的所有质数  
                        Toast.makeText(CalPrime.this , nums.toString()  
                            , Toast.LENGTH_LONG).show();  
                    }  
                }  
            };  
            Looper.loop();  
        }  
    }  
    @Override  
    public void onCreate(Bundle savedInstanceState)  
    {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.main);  
        etNum = (EditText)findViewById(R.id.etNum);  
        calThread = new CalThread();  
        // 启动新线程  
        calThread.start();  
    }  
    // 为按钮的点击事件提供事件处理函数  
    public void cal(View source)  
    {  
        // 创建消息  
        Message msg = new Message();  
        msg.what = 0x123;  
        Bundle bundle = new Bundle();  
        bundle.putInt(UPPER_NUM ,  
            Integer.parseInt(etNum.getText().toString()));  
        msg.setData(bundle);  
        // 向新线程中的Handler发送消息  
        calThread.mHandler.sendMessage(msg);  
    }  
}

UI线程sendMessage

handler里面handleMessage

https://www.runoob.com/w3cnote/android-tutorial-handler-message.html

https://blog.csdn.net/u013168615/article/details/47024073/

sendEmptyMessage和sendMessage没啥区别，sendEmptyMessage多了一步传what
区分你send一个0和1，处理的时候就要判断了if(msg.what == 0){}else if(msg.what == 1){}

blic final boolean sendEmptyMessage(int what)
{
   return sendEmptyMessageDelayed(what, 0);
}

public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
Message msg = Message.obtain();
msg.what = what;
return sendMessageDelayed(msg, delayMillis);
}

public final boolean sendMessage(Message msg)
{
return sendMessageDelayed(msg, 0);
}

4.Handler post

源码

/**
     * Causes the Runnable r to be added to the message queue.
     * 这里源码注释的意思是：把r这个任务对象添加到消息队列中。
     */
    public final boolean post(Runnable r)
    {
       return  sendMessageDelayed(getPostMessage(r), 0);
    }

/**
     * Enqueue a message into the message queue after all pending messages
*然后我们接着看post方法中直接调用到的发送延时消息的方法，源码注释*的意思是把这个消息放入消息队列，
     */
    public final boolean sendMessageDelayed(Message msg, long delayMillis)
    {
        if (delayMillis < 0) {
            delayMillis = 0;
        }
        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
    }

/*最后我们再看post中调用的另外一个方法，源码中没有注释，但我们很容易看出来，这个方法就是把r这个任务包装成了一个空的消息并且返回*/
private static Message getPostMessage(Runnable r) {
        Message m = Message.obtain();
        m.callback = r;
        return m;
}

结论：
handler.post和handler.sendMessage本质上是没有区别的
都是发送一个消息到消息队列中
而且消息队列和handler都是依赖于同一个线程的。

分别用sendMessage和post完成同样的异步更新UI的任务：

private TextView tv_up;
    private String new_str = "";
    /*post方法解决UI更新问题handler创建方式*/
    private Handler handler_post = new Handler();
    /*sendMessage方法解决UI更新问题handler创建方式*/
    Handler handler_senM = new Handler() {
        public void handleMessage(Message msg) {
            if (msg.what == 1) {
                /*sendMessage方法更新UI的操作必须在handler的handleMessage回调中完成*/
                tv_up.setText(new_str);
            }
        };
    };
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        new Thread(new Runnable() {

            @Override
            public void run() {
                new_str = "更新UI";
                /*sendMessage方法解决UI更新发送消息给handler（主线程中的handler）*/
                handler_senM.sendEmptyMessage(1);
                /*post方法解决UI更新，直接在runnable里面完成更新操作，这个任务会被添加到handler所在线程的消息队列中，即主线程的消息队列中*/
                handler_post.post(new Runnable() {

                    @Override
                    public void run() {
                        tv_up.setText(new_str);
                    }
                });
            }
        }).start();
    }

从这段代码中我们可以看出：
post和sendMessage只是用法上的区别，本质是没有区别的。

最终总结：

1. post和sendMessage本质上是没有区别的，只是实际用法中有一点差别
2. post也没有独特的作用，post本质上还是用sendMessage实现的，post只是一中更方便的用法而已

handler.sendMessage 需要在定义Handler的位置Override handleMessage
handler.post(@NonNull Runnable r) 直接在runnable中完成更新操作就行