Android实习生 —— 异步处理之Handler

96
博儿丶
2017.04.02 19:22* 字数 2260

目录

前言
  ActivityThread
    1、简介特点
    2、主要责任
    3、特别规定(必须遵循)
    4、知识扩展
一、Handler简述
    Handler是什么
    两个作用
    常用方法
二、Handler实现原理
    1、相关概念
    2、为什么要用handler机制更新UI
    3、handler实现流程
三、Handler实例(Demo)
    1、安排消息或Runnable 在某个主线程中某个地方执行;
    2、安排一个动作在其他的线程中执行。(其他线程通过Handler机制UI线程中Button的内容)
    3、HandlerThread 总结使用
      (1)引言
      (2)常规用法
      (3)小实例
【附录】
Demo

前言

在学习Handler之前,我们要先了解一下ActivityThread(主线程或UI线程)。

1、简介特点

  • 管理应用进程的主线程的执行(相当于普通Java程序的main入口函数),并根据AMS的要求负责调度和执行activities、broadcasts和其它操作。

  • 默认情况下,一个应用程序内的各个组件(如Activity、BroadcastReceiver、Service)都会在同一个进程(Process)里执行,且由此进程的【主线程】负责执行。 如果有特别指定(通过android:process),也可以让特定组件在不同的进程中运行。

2、主要责任

  • 责任1: 快速处理UI事件
    只有它才处理UI事件, 其它线程还不能存取UI画面上的对象(如TextView等),所以, 主线程也叫做UI线程。

  • 责任2: 快速处理Broadcast消息
    在BroadcastReceiver的onReceive()函数中,不宜占用太长的时间,否则导致【主线程】无法处理其它的Broadcast消息或UI事件。

3、特别规定(必须遵循)

  • 规定1:不可以在UI线程做耗时操作
    Android要求UI线程能根据用户的要求做出快速响应,如果UI事件让用户等待时间超过5秒而未处理,或者在广播接收者操作占用时间超过10秒, Android系统就会给用户显示ANR(Application is not responding)提示信息。
//产生耗时操作
bt1.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                try {
                    // 让UI线程睡上20s
                    Thread.sleep(20000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
ANR
  • 规定2:不可以子线程中更新UI
    Android要求在创建了ViewRootImpl之后不可在非UI线程中更新UI。
    举例:
        bt1.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        bt1.setText("子线程操作UI");
                    }
                }).start();
            }
        });

异常

Process: com.bb.handlerdemo, PID: 2531
android.view.ViewRootImpl$CalledFromWrongThreadException: Only the original thread that created a view hierarchy can touch its views.

4、知识扩展

  • 如果我们把子线程操作UI的代码这样写,反而没有报异常
protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        bt1= (Button) findViewById(R.id.bt1);
//        bt1.setOnClickListener(new View.OnClickListener() {
//            @Override
//            public void onClick(View view) {
//                new Thread(new Runnable() {
//                    @Override
//                    public void run() {
//                        bt1.setText("子线程操作UI");
//                    }
//                }).start();
//            }
//        });
        
        new Thread(new Runnable() {
            @Override
            public void run() {

                bt1.setText("子线程操作UI1");
            }
        }).start();
        
    }

解释:在onCreate方法中创建的子线程访问UI是一种极端的情况。
ViewRootImpl的创建是在onResume方法回调之后,而我们是在onCreate方法中创建了子线程并访问UI,在那个时刻,ViewRootImpl是没有创建的,无法通过checkThread方法检查当前线程,所以程序没有崩溃一样能跑起来。
如果我们在线程里睡眠1秒钟,程序就崩了。很明显1秒后ViewRootImpl已经创建了。

一、Handler简述

  • Handler是什么

    若把一些类似于下载的功能(既耗时且不一定有结果)写在Activity(主线程)里,会违背“前言中写到特别规定”从而导致Activity线程阻塞,产生ANR提示。因此,需要把这些耗时的操作放在单独的子线程中。这就是Handler的使命,Handler提供异步处理的功能,接受子线程发送的数据,并用此数据配合主线程更新UI。

    【android在设计的时候就封装了一套消息创建、传递、处理的Handler机制。如果不遵循就不能更新UI信息,就会报出异常。】

  • 两个作用

    (1)安排消息或Runnable 在某个主线程中某个地方执行;
    (2)安排一个动作在不同的线程中执行。

  • 常用方法

//post类方法允许你排列一个Runnable对象到主线程队列中
post(Runnable)//将Runnable直接添加入队列
postAtTime(Runnable,long)//延迟一定时间后,将Runnable添加入队列
postDelayed(Runnable long)//定时将Runnable添加入队列

  //sendMessage类方法, 允许你安排一个带数据的Message对象到队列中,等待更新。
sendEmptyMessage(int what)//向队列添加直接添加消息, 与sendMessage相比一个传
//Message类型的msg,一个传int类型的what,传what的,最终会转为msg。
sendMessage(Message)//向队列添加直接添加消息
sendMessageAtTime(Message,long)//定时将消息发送到消息队列
sendMessageDelayed(Message,long)//延迟一定时间后,将消息发送到消息队列

二、Handler实现原理

1、相关概念
  • Message
    消息,理解为线程间通讯的数据单元。例如后台线程在处理数据完毕后需要更新UI,则可发送一条包含更新信息的Message给UI线程。

  • Message Queue
    消息队列,由Looper管理,用来存放通过Handler发布的消息,按照先进先出执行。

  • Handler
    Handler是Message的主要处理者,它把消息发送给Looper管理的MessageQueue,并负责处理Looper分发给他的消息。
    每个Handler实例,都会绑定到创建他的线程中(一般是位于主线程)。

  • Looper
    循环器,每个线程只有一个Looper,他负责管理MessageQueue,会不断的从MessageQueue取出消息,分发给对象的handler。

为了保证当前线程有Looper对象,可以有两种情况处理。

  • (1)主ui线程启动,系统就初始化了一个Looper对象,只要在程序中直接创建handler,它就会和Looper自动绑定,然后用handler发送和处理消息。

  • (2)我们自己创建的线程要自己手动创建一个Looper对象了,因为除主线程外,Android中的线程默认是没有开启Looper的。创建Looper对象调用它的prepare()方法 是为了保证每个线程最多一个Looper对象。然后用Looper.loop()启动它。此时loop()方法就会使用一个死循环不断地取出MessageQueue()中的消息,并将消息分给所对应的Handler处理。

  • 【注意】写在Looper.loop()之后的代码不会被执行,这个函数内部应该是一个循环,当调用mHandler.getLooper().quit()后,loop才会中止,其后的代码才能得以运行。

  • 线程
    UI thread 通常就是main thread,而Android启动程序时会替它建立一个Message Queue。

  • 总结
    ** Handler负责发送消息,Loop负责接收到Message Queue容器中**
    一个线程里只有一个Looper对象以及一个MessageQueue数据结构。在你的应用程序里,可以定义多个Handler实例

    流程

2、为什么要用handler机制更新UI

最根本的目的就是为了解决多线程并发的问题!如果在一个activity中有多个线程去更新UI,并且没有加锁,就会出现界面错乱的问题。但是如果对这些更新UI的操作都加锁处理,又会导致性能下降。
处于对性能的问题考虑,不用再去关系多线程的问题,所有的更新UI的操作,都是在主线程的消息队列中去轮训的。

3、handler实现流程
协作关系

三、Handler实例(Demo)

1、安排消息或Runnable 在某个主线程中某个地方执行;
public class MainActivity extends Activity {
    //Handler安排 Runnable 在某个主线程中某个地方执行
    Handler handler = new Handler();
    Runnable thread = new Runnable() {
        @Override
        public void run() {
            System.out.println("HandlerThread:" + Thread.currentThread().getId());
        }
    };
    private Button start;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        start = (Button) findViewById(R.id.start);
        start.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                handler.post(thread);
            }
        });
        System.out.println("Activity Thread:" + Thread.currentThread().getId());
    }
}

这个程序看上去似乎实现了Handler的异步机制,handler.post(thread)似乎实现了新启线程的作用,不过通过执行我们发现,两个线程的ID相同!也就是说,实际上thread还是原来 的主线程,由此可见,handler.post()方法并未真正新建线程,只是在原线程上执行而已,我们并未实现异步机制。我们再看下面这个Demo。

2、安排一个动作在其他的线程中执行。(其他线程通过Handler机制UI线程中Button的内容)
public class MainActivity extends Activity {
    Button button;
    MyHandler myHandler;

    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        button = (Button) findViewById(R.id.start);
        //打印主线程id
        Log.d("ThreadId", "MainThreadId:"+Thread.currentThread().getId()+"");
        
        // 当创建一个新的Handler实例时,它会绑定到当前线程和消息的队列中,开始分发数据
        myHandler = new MyHandler();
        
        //开启子线程
        MyThread m = new MyThread();
        new Thread(m).start();
    }

    /**
     * 接收消息,处理消息 ,此Handler会与当前主线程一块运行
     * */

    class MyHandler extends Handler {
        public MyHandler() {
        }

        public MyHandler(Looper L) {
            super(L);
        }

        // 子类必须重写此方法,接收数据
        @Override
        public void handleMessage(Message msg) {
            Log.d("MyHandler", "handleMessage。。。。。。");
            super.handleMessage(msg);
            // 此处可以更新UI
            Bundle b = msg.getData();
            String color = b.getString("color");
            MainActivity.this.button.setText(color);

        }
    }

    class MyThread implements Runnable {
        public void run() {
            try {
                //6秒执行完毕
                Thread.sleep(6000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Log.d("ThreadId","MainThreadId:"+Thread.currentThread().getId()+"");
            Message msg = new Message();
            Bundle b = new Bundle();// 存放数据
            b.putString("color","我的名字");
            msg.setData(b);
            MainActivity.this.myHandler.sendMessage(msg); // 向Handler发送消息,更新UI

        }
    }
}
打印不同线程id

通过打印我们可以看到,两个ID是不同的,新的线程启动了!

3、HandlerThread 总结使用

(1)引言:我们为一个非主线程开启一个Handler时候需要这么做



很明显的一点就是,我们要在子线程中调用Looper.prepare() 为一个线程开启一个消息循环,默认情况下Android中新诞生的线程是没有开启消息循环的。(主线程除外,主线程系统会自动为其创建Looper对象,开启消息循环。) Looper对象通过MessageQueue来存放消息和事件。一个线程只能有一个Looper,对应一个MessageQueue。 然后通过Looper.loop() 让Looper开始工作,从消息队列里取消息,处理消息。

注意:写在Looper.loop()之后的代码不会被执行,这个函数内部应该是一个循环,当调用mHandler.getLooper().quit()后,loop才会中止,其后的代码才能得以运行。

「其实这一切都可以用HandlerThread类来帮我们做。」

(2)常规用法

  • 创建一个HandlerThread
    mThread = new HandlerThread("handler_thread");

  • 启动一个HandlerThread
    mThread.start();

(3)小实例

public class MainActivity extends AppCompatActivity {
    private HandlerThread myHandlerThread;
    private Handler handler;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //创建一个线程,线程名字:handler-thread
        myHandlerThread = new HandlerThread("handler-thread");
        //开启一个线程
        myHandlerThread.start();
        //在这个线程中创建一个handler对象
        handler = new Handler(myHandlerThread.getLooper()) {
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                //这个方法是运行在 handler-thread 线程中的 ,可以执行耗时操作
                Log.d("handler ", "消息: " + msg.what + "  线程: " + Thread.currentThread().getName());
            }
        };
        //在主线程给handler发送消息
        handler.sendEmptyMessage(1);
        new Thread(new Runnable() {
            @Override
            public void run() {
                //在子线程给handler发送数据
                handler.sendEmptyMessage(2);
            }
        }).start();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        //释放资源
        myHandlerThread.quit();
    }
}
运行效果:
/com.app D/handler: 消息: 1  线程: handler-thread
/com.app D/handler: 消息: 2  线程: handler-thread

(4)HandlerThread的特点

  • HandlerThread将loop转到子线程中处理,说白了就是将分担MainLooper的工作量,降低了主线程的压力,使主界面更流畅。

  • HandlerThread拥有自己的消息队列,它不会干扰或阻塞UI线程。

  • 对于网络IO操作,HandlerThread并不适合,因为它只有一个线程,还得排队一个一个等着。

【附录】

Demo

1、安排消息或Runnable 在某个主线程中某个地方执行;

2、安排一个动作在其他的线程中执行。(其他线程通过Handler机制UI线程中Button的内容)

3、HandlerThread 总结使用


整理作者:汪博
少壮不努力,老大徒悲伤。
本文为Android学习规划打造,如有不好的地方请多多指教。

Android复习
Web note ad 1