首页 > 编程语言> > android系统核心机制基础（05）handler使用案例(Java)

android系统核心机制基础（05）handler使用案例(Java)

2019-06-08 13:56:19 作者：互联网

系列文章解读&说明：

Android系统核心机制基础的分析主要分为以下部分：

（01）智能指针wp & sp

（02）Thread类解析

（03）Thread同步机制

（04）handler message机制 java

（05）handler使用案例(Java)

（06）handler message机制 Native

（07）AsyncChannel机制浅析

（08）JNI 基础

（09）Android 添加新模块

本模块分享的内容：handler使用案例(Java)

本章关键点总结 & 说明：

这里关注➕handler message机制中java 层案例 demo，是handler的一些使用案例，针对handler和HandlerThread关键类

handler的常见使用实例(Java)
当应用程序启动时，Android首先会开启一个主线程(也就是UI线程)，主线程为管理界面中的UI控件进行事件分发比如说：点击一个Button，Android会分发事件到Button上，来响应你的操作。如果此时需要一个耗时的操作。例如: 联网读取数据，或者读取本地较大的一个文件的时候，你不能把这些操作放在主线程中，如果你放在主线程中的话，界面会出现假死现象，如果5秒钟还没有完成，则会收到Android系统的一个错误提示"强制关闭"。这时我们需要把这些耗时操作放在一个子线程中，因为子线程涉及到UI更新，Android主线程是线程不安全的，即更新UI只能在主线程中更新，子线程中操作是危险的。这个时候，Handler就出现了，来解决这个复杂的问题，由于Handler运行在主线程中(UI线程中)，它与子线程可以通过Message对象来传递数据，这个时候，Handler就承担着接收子线程传过来的(子线程用sendMessage()方法传递)Message对象(里面包含数据)，把这些消息放入主线程队列中，配合主线程进行UI更新。
1 实例1(介绍最简单的Handler使用，是将Handler绑定到它所建立的线程中)
本次实例完成的功能是：

单击“开始”按钮，程序会启动线程，且线程程序完成后延时1s后继续启动该线程，每次线程的run函数中完成对界面输出UpdateThread.
单击 “结束”按钮时，该线程就会停止，如果继续单击“开始”，则文字又开始输出了。

关键源代码如下：

public class MainActivity extends Activity {  
  
    private TextView text_view = null;  
    private Button start = null;  
    private Button end = null;  
  
    Handler handler = new Handler();  //使用handler时首先要创建一个handler  
    //要用handler来处理多线程可以使用runnable接口，这里先定义该接口  
    //线程中运行该接口的run函数  
    Runnable update_thread = new Runnable()  
    {  
        public void run()  
        {  
            text_view.append("\nUpdateThread...");  //线程每次执行时输出"UpdateThread..."文字,\n为自动换行
            handler.postDelayed(update_thread, 1000);  //延时1s后又将线程加入到线程队列
        }
    };  
  
    @Override  
    public void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
  
        text_view = (TextView)findViewById(R.id.text_view);  
        start = (Button)findViewById(R.id.start);  
        start.setOnClickListener(new StartClickListener());  
        end = (Button)findViewById(R.id.end);  
        end.setOnClickListener(new EndClickListener());    
    }  
  
    private class StartClickListener implements OnClickListener  
    {  
        public void onClick(View v) {  
            handler.post(update_thread);  //将线程接口立刻送到线程队列中  
        }                  
    }  
  
    private class EndClickListener implements OnClickListener  
    {    
        public void onClick(View v) {  
            handler.removeCallbacks(update_thread);  //将接口从线程队列中移除 
        }  
    }  
}

关键布局文件如下：

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
        xmlns:tools="http://schemas.android.com/tools"  
        android:layout_width="match_parent"  
        android:layout_height="match_parent"  
        android:orientation="vertical" >  
      
        <TextView  
            android:id="@+id/text_view"  
            android:layout_width="fill_parent"  
            android:layout_height="200dip"  
            android:text="@string/hello_world"  
            tools:context=".MainActivity" />  
        <Button   
            android:id="@+id/start"  
            android:layout_width="fill_parent"  
            android:layout_height="wrap_content"  
            android:text="开始"  
            />  
        <Button   
            android:id="@+id/end"  
            android:layout_width="fill_parent"  
            android:layout_height="wrap_content"  
            android:text="结束"  
            />  
      
    </LinearLayout>

2 实例2

这里用到了Handler的消息队列机制，即通过Handler中一个线程向消息队列中用sendMessage方法发送消息，发送的消息当然可以用来传递参数。在Handler中用handleMessage来处理消息，处理方法是获得消息队列中的消息参数，用这些参数来完成另外一些功能：当“Start”按钮按下时，会启动一个线程并绑定到Handler中，该线程发送带有参数的message到handler的消息队列中，消息队列的另一端获取该消息，并且用该消息的参数来更新进度条。关键代码实现如下：

public class MainActivity extends Activity {  
    private ProgressBar progress_bar = null;  
    private Button start = null;  
  
    @Override  
    public void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
        progress_bar = (ProgressBar) findViewById(R.id.progress_bar);  
        start = (Button) findViewById(R.id.start);  
  
        start.setOnClickListener(new StartOnClickListener());  
    }  
  
    private class StartOnClickListener implements OnClickListener {  
        public void onClick(View v) {  
            // 让进度条显示出来  
            progress_bar.setVisibility(View.VISIBLE);  
            // 将线程加入到handler的线程队列中  
            update_progress_bar.post(update_thread);  
        }  
    }  
  
    // 创建一个handler，内部完成处理消息方法  
    Handler update_progress_bar = new Handler() {  
        @Override  
        public void handleMessage(Message msg) {  
            // super.handleMessage(msg);  
            // 显示进度条  
            progress_bar.setProgress(msg.arg1);  
            // 重新把进程加入到进程队列中  
            update_progress_bar.post(update_thread);  
        }  
    };// 不加这个分号则不能自动添加代码  
  
    Runnable update_thread = new Runnable() {  
        int i = 0;  
  
        public void run() {  
            i += 10;              
            Message msg = update_progress_bar.obtainMessage();  //首先获得一个消息结构  
            msg.arg1 = i;   // 给消息结构的arg1参数赋值 
            try {  
                Thread.sleep(1000);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
            // 把消息发送到消息队列中  
            update_progress_bar.sendMessage(msg);  
            if (i == 100) {// 把线程从线程队列中移除  
                update_progress_bar.removeCallbacks(update_thread);  
            }  
        }  
    };  
}

布局文件如下：

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
        xmlns:tools="http://schemas.android.com/tools"  
        android:layout_width="match_parent"  
        android:layout_height="match_parent"  
        android:orientation="vertical" >  
      
        <Button   
            android:id="@+id/start"  
            android:layout_width="fill_parent"  
            android:layout_height="wrap_content"  
            android:layout_alignParentBottom="true"  
            android:text="@string/start"  
            />  
        <ProgressBar   
            android:id="@+id/progress_bar"  
            android:layout_width="fill_parent"  
            android:layout_height="100dip"  
            android:layout_alignParentTop="true"  
            style="?android:attr/progressBarStyleHorizontal"  
            android:visibility="gone"  
            />  
      
    </LinearLayout>

注意：表面上看Handler使用了post方法启动了runnbale，其实启动的线程和activity主线程是同一个线程，因为它只是运行了线程的run方法，而不是start方法。
-------------------------------------------------
3 实例3(HandleThread的使用实例)
功能说明：用HandlerThread的looper来构造一个handler，然后该handler自己获得消息并传递数据，然后又自己处理消息，当然这是在另一个线程中完成的。消息结构中传递简单的整型可以采用它的参数arg1和arg2，或者传递一些小的其它数据，可以用它的Object，该Object可以是任意的对象。当需要传送比较大的数据是，可以使用消息的setData方法，该方法需要传递一个Bundle的参数。Bundle中存放的是键值对的map，只是它的键值类型和数据类型比较固定而已。关键代码如下所示：

public class MainActivity extends Activity {  
  
    @Override  
    public void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
  
        System.out.println("activity_ID---->"+Thread.currentThread().getId());  
        //新建一个HanderThread对象，该对象实现了用Looper来处理消息队列的功能  
        HandlerThread handler_thread = new HandlerThread("handler_thread");  
        handler_thread.start();  
        //MyHandler类是自己继承的一个类，这里采用hand_thread的Looper来初始化它  
        MyHandler my_handler = new MyHandler(handler_thread.getLooper());  
        //获得一个消息msg  
        Message msg = my_handler.obtainMessage();  
  
        //采用Bundle保存数据，Bundle中存放的是键值对的map，只是它的键值类型和数据类型比较固定而已  
        Bundle b = new Bundle();  
        b.putString("whether", "晴天");  
        b.putInt("temperature", 34);  
        msg.setData(b);  
        //将msg发送到自己的handler中，这里指的是my_handler,调用该handler的HandleMessage方法来处理该mug  
        msg.sendToTarget();  
    }  
  
    class MyHandler extends Handler  
    {  
        //空的构造函数  
        public MyHandler()  
        {}  
        //以Looper类型参数传递的函数，Looper为消息泵，不断循环的从消息队列中得到消息并处理，因此  
        //每个消息队列都有一个Looper，因为Looper是已经封装好了的消息队列和消息循环的类  
        public MyHandler(Looper looper)  
        {  
            //调用父类的构造函数  
            super(looper);  
        }  
        @Override  
        public void handleMessage(Message msg) {  
            //此处能看到，消息处理不是在主线程中执行的  
            System.out.println("Handler_ID---->"+Thread.currentThread().getId());  
            System.out.println("Handler_Name---->"+Thread.currentThread().getId());  
            //将消息中的bundle数据取出来  
            Bundle b = msg.getData();  
            String whether = b.getString("whether");  
            int temperature = b.getInt("temperature");  
            System.out.println("whether= "+whether+" ,temperature= "+temperature);  
        }  
    }  
}

4 总结(Handler && Looper && MessageQueue,Java)
Android中的handler可以用来完成异步的消息出来，即发送消息和接收消息相互独立，可以同时运行。在例1和例2中，实际上handler中使用的线程是与它所在的activity处于同一个主线程，因为handler中调用的runnable接口是直接运行该接口的run函数的，而不是start函数。在例3学会使用怎样在新线程中处理消息的方法。

标签：Java,05,update,系统核心,handler,线程,消息,Handler,public
来源： https://blog.csdn.net/vviccc/article/details/91128038

android系统核心机制 基础（05）handler使用案例(Java)

系列文章解读&说明：

本章关键点总结 & 说明：

android系统核心机制基础（05）handler使用案例(Java)