Android（java）学习笔记134：Handler用法总结 和 秒表案例

时间：2023-09-04 09:00:08

一、Handler的定义:
Handler主要接收子线程发送的数据, 并用此数据配合主线程更新UI，用来跟UI主线程交互用。比如可以用handler发送一个message，然后在handler的线程中来接收、处理该消息，以避免直接在UI主线程中处理事务导致影响UI主线程的其他处理工作，Android提供了Handler作为主线程和子线程的纽带；也可以将handler对象传给其他进程，以便在其他进程中通过handler给你发送事件；还可以通过handler的延时发送message，可以延时处理一些事务的处理。
通常情况下，当应用程序启动时，Android首先会开启一个主线程 (也就是UI线程) , 主线程为管理界面中的UI控件，进行事件分发。如果此时需要一个耗时的操作，例如:联网读取数据，或者读取本地较大的一个文件的时候，你不能把这些操作放在主线程中，如果你放在主线程中的话，界面会出现假死现象,如果5秒钟还没有完成的话，会收到Android系统的一个错误提示"强制关闭".
这个时候我们需要把这些耗时的操作，放在一个子线程中,因为子线程涉及到UI更新，但是当子线程中有涉及到操作UI的操作时，就会对主线程产生危险，也就是说，更新UI只能在主线程中更新，在子线程中操作是危险的. 这个时候，Handler就出现了来解决这个复杂的问题，由于Handler运行在主线程中(UI线程中)，它与子线程可以通过Message对象来传递数据，这个时候，Handler就承担着接受子线程传过来的(子线程用sedMessage()方法传递)Message对象，(里面包含数据), 把这些消息放入主线程队列中，配合主线程进行更新UI。

二、Handler一些特点
handler可以分发Message对象和Runnable对象到主线程中, 每个Handler实例,都会绑定到创建他的线程中(一般是位于主线程), 也就是说Handler对象初始化后，就默认与对它初始化的进程的消息队列绑定（这里一般是主线程的消息队列），因此可以利用Handler所包含的消息队列，制定一些操作的顺序。

三、Handler中分发消息的一些方法
post(Runnable)
postAtTime(Runnable,long)
postDelayed(Runnable long)
post类方法允许你排列一个Runnable对象到主线程队列中
sendEmptyMessage(int)
sendMessage(Message)
sendMessageAtTime(Message,long)
sendMessageDelayed(Message,long)
sendMessage类方法, 允许你安排一个带数据的Message对象到队列中，等待更新.

四、应用实例：
1，传递Message。用于接受子线程发送的数据, 并用此数据配合主线程更新UI。
在Android中，对于UI的操作通常需要放在主线程中进行操作。如果在子线程中有关于UI的操作，那么就需要把数据消息作为一个Message对象发送到消息队列中，然后，用Handler中的handlerMessge方法处理传过来的数据信息，并操作UI。类sendMessage(Message msg)方法实现发送消息的操作。 在初始化Handler对象时重写的handleMessage方法来接收Messgae并进行相关操作。
2，传递Runnable对象。用于通过Handler绑定的消息队列，安排不同操作的执行顺序。
Handler对象在进行初始化的时候，会默认的自动绑定消息队列。利用类post方法，可以将Runnable对象发送到消息队列中，按照队列的机制按顺序执行不同的Runnable对象中的run方法。
另外，Android的CPU分配的最小单元是线程，Handler一般是在某个线程里创建的，因而Handler和Thread就是相互绑定的，一一对应。而Runnable是一个接口，Thread是Runnable的子类。所以说，他俩都算一个进程。

e.g:

  public class HandlerActivity extends Activity {

2.

3.      //声明两个按钮控件

4.      private Button startButton = null;

5.      private Button endButton = null;

6.      @Override

7.      public void onCreate(Bundle savedInstanceState) {

8.          super.onCreate(savedInstanceState);

9.          setContentView(R.layout.main);

10.         //根据控件的ID得到代表控件的对象，并为这两个按钮设置相应的监听器

11.         startButton = (Button)findViewById(R.id.startButton);

12.         startButton.setOnClickListener(new StartButtonListener());

13.         endButton = (Button)findViewById(R.id.endButton);

14.         endButton.setOnClickListener(new EndButtonListener());

15.

16.     }

17.     class StartButtonListener implements OnClickListener{

18.

19.         @Override

20.         public void onClick(View v) {

21.             //调用Handler的post方法，将要执行的线程对象添加到队列当中

22.             handler.post(updateThread);

23.         }

24.

25.     }

26.

27.     class EndButtonListener implements OnClickListener{

28.

29.         @Override

30.         public void onClick(View v) {

31.             handler.removeCallbacks(updateThread);

32.         }

33.

34.     }

35.     //创建一个Handler对象

36.     Handler handler  = new Handler();

37.     //将要执行的操作写在线程对象的run方法当中

38.     Runnable updateThread =  new Runnable(){

39.

40.         @Override

41.         public void run() {

42.             System.out.println("UpdateThread");

43.             //在run方法内部，执行postDelayed或者是post方法

44.             handler.postDelayed(updateThread, 3000);

45.         }

46.

47.     };

48. }

程序的运行结果就是每隔 3 秒钟，就会在控制台打印一行UpdateTread。这是因为实现了Runnable接口的updateThread对象进入了空的消息队列即被立即执行run方法，而在run方法的内部，又在3000ms之后将其再次发送进入消息队列中。

3.Handler和多线程

post方法虽然发送的是一个实现了Runnable接口的类对象，但是它并非创建了一个新线程，而是执行了该对象中的run方法。也就是说，整个run中的操作和主线程处于同一个线程。这样对于那些简单的操作，似乎并不会影响。但是对于耗时较长的操作，就会出现“假死”。为了解决这个问题，就需要使得handler绑定到一个新开启线程的消息队列上，在这个处于另外线程的上的消息队列中处理传过来的Runnable对象和消息。

1.  public class HandlerTest2 extends Activity {

2.

3.      @Override

4.      protected void onCreate(Bundle savedInstanceState) {

5.          // TODO Auto-generated method stub

6.      super.onCreate(savedInstanceState);

7.      setContentView(R.layout.main);

8.      //打印了当前线程的ID

9.      System.out.println("Activity-->" + Thread.currentThread().getId());

10.     //生成一个HandlerThread对象

11.     HandlerThread handlerThread = new HandlerThread("handler_thread");

12.     //在使用HandlerThread的getLooper()方法之前，必须先调用该类的start()，同时开启一个新线程;

13.     handlerThread.start();

14.     //将由HandlerThread获取的Looper传递给Handler对象，即由处于另外线程的Looper代替handler初始化时默认绑定的消息队列来处理消息。

15.      // HandlerThread顾名思义就是可以处理消息循环的线程，它是一个拥有Looper的线程

16. //，可以处理消息循环；  其实与其说Handler和一个线程绑定，倒不如说Handler和Looper是

17. //一一对应的。

18.     MyHandler myHandler = new MyHandler(handlerThread.getLooper());

19.     Message msg = myHandler.obtainMessage();

20.     //将msg发送到目标对象，所谓的目标对象，就是生成该msg对象的handler对象

21.     Bundle b = new Bundle();

22.     b.putInt("age", 20);

23.     b.putString("name", "Jhon");

24.     msg.setData(b);

25.     msg.sendToTarget();  //将msg发送到myHandler

26.     }

27.

28.     //定义类

29.     class MyHandler extends Handler{

30.     public MyHandler(){

31.

32.     }

33.

34.     public MyHandler(Looper looper){

35.         super(looper);

36.     }

37.     @Override

38.     public void handleMessage(Message msg) {

39.         Bundle b = msg.getData();

40.         int age = b.getInt("age");

41.         String name = b.getString("name");

42.         System.out.println("age is " + age + ", name is" + name);

43.         System.out.println("Handler--->" + Thread.currentThread().getId());

44.         System.out.println("handlerMessage");

45.         }

46.     }

47. }

这样，当使用sendMessage方法传递消息或者使用post方法传递Runnable对象时，就会把它们传递到与handler对象绑定的处于另外一个线程的消息队列中，它们将在另外的消息队列中被处理。而主线程还会在发送操作完成时候继续进行，不会影响当前的操作。

这里需要注意，这里用到的多线程并非由Runnable对象开启的，而是ThreadHandler对象开启的。Runnable对象只是作为一个封装了操作的对象被传递，并未产生新线程。

另外再强调一遍，在UI线程（主线程）中：

mHandler=new Handler();

mHandler.post(new Runnable(){

void run(){

//执行代码..

}

});

这个线程其实是在UI线程之内运行的，并没有新建线程。

常见的新建线程的方法是：

   Thread thread = new Thread();

    thread.start();

HandlerThread thread = new HandlerThread("string");

    thread.start();

 五、秒表案例：

（1）AndroidManifest.xml 清单文件：

<?xml version="1.0" encoding="utf-8"?>

<manifest xmlns:android="http://schemas.android.com/apk/res/android"

      package="cn.itcast.time"

      android:versionCode="1"

      android:versionName="1.0">

    <uses-sdk

        android:minSdkVersion="15"

        android:targetSdkVersion="17" />

    <application android:icon="@drawable/icon" android:label="@string/app_name">

        <activity android:name=".MainActivity"

                  android:label="@string/app_name">

            <intent-filter>

                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />

            </intent-filter>

        </activity>

    </application>

</manifest>

（2）main.xml文件：

<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

    android:orientation="vertical"

    android:layout_width="fill_parent"

    android:layout_height="fill_parent"

    >

    <LinearLayout

        android:orientation="horizontal"

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:gravity="center"

        >

        <TextView

            android:layout_width="20dip"

            android:layout_height="wrap_content"

            android:id="@+id/min"

            />

        <TextView

            android:layout_width="20dip"

            android:layout_height="wrap_content"

            android:id="@+id/sec"

            />

    </LinearLayout>

        <Button

            android:layout_width="wrap_content"

            android:layout_height="wrap_content"

            android:text="start"

            android:id="@+id/button"

            />

             <Button

            android:layout_width="wrap_content"

            android:layout_height="wrap_content"

            android:text="stop"

            android:id="@+id/stop"

            />

</LinearLayout>

（3）MainActivity.java文件：

package cn.itcast.time;

import android.app.Activity;

import android.app.AlertDialog;

import android.content.DialogInterface;

import android.content.DialogInterface.OnClickListener;

import android.os.Bundle;

import android.os.Handler;

import android.os.Message;

import android.view.View;

import android.widget.Button;

import android.widget.TextView;

public class MainActivity extends Activity {

    private TextView minText;

    private TextView secText;

    private boolean paused = false;

    private String timeUsed;

    private int timeUsedInSec;

    private Handler uiHandler = new Handler() {//handler线程是主要用来和UI主线程进行交互的

        @Override

        public void handleMessage(Message msg) {

            super.handleMessage(msg);

            switch (msg.what) {

            case 1:

                if (!paused)

                {

                    addTimeUsed();

                    updateClockUI();

                }

                uiHandler.sendEmptyMessageDelayed(1, 1000);//延时1s

                break;

            default:

                break;

            }

        }

    };

    @Override

    public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.main);

        minText = (TextView) this.findViewById(R.id.min);

        secText = (TextView) this.findViewById(R.id.sec);

        Button button = (Button) this.findViewById(R.id.button);

        Button  sbutton=(Button)this.findViewById(R.id.stop);

        sbutton.setOnClickListener(new View.OnClickListener() {//stop按钮

            @Override

            public void onClick(View v) {

            paused = true;

            timeUsedInSec=0;

            minText.setText("00"+":");

            secText.setText("00");

            }

        });

        button.setOnClickListener(new View.OnClickListener() {//start按钮

            @Override

            public void onClick(View v) {

                uiHandler.removeMessages(1);//每次将消息标志为“1"的消息移除消息队列,有可能之前start过,已经存在"1"在消息队列中,所以这里先移除再发送

                startGame();//handler发送消息标志为“1"的消息到消息队列

                paused = false;

                }

        });

    }

    @Override

    protected void onPause() {

        super.onPause();

        paused = true;

    }

    @Override

    protected void onResume() {

        super.onResume();

        paused = false;

    }

    private void startGame() {

        uiHandler.sendEmptyMessageDelayed(1, 1000);

    }

    // 更新时间的显示

    private void updateClockUI() {

        minText.setText(getMin()+":");

        secText.setText(getSec());

    }

    public void addTimeUsed() {//秒钟自动增加

        timeUsedInSec=timeUsedInSec+1;

        timeUsed = this.getMin() + ":" + this.getSec();

    }

    public CharSequence getMin() {//CharSequence和String都用来修饰定义字符串

        return String.valueOf(timeUsedInSec / 60);

    }

    public CharSequence getSec() {

        int sec = timeUsedInSec % 60;

        return sec < 10 ? "0" + sec : String.valueOf(sec);

    }

}

相关文章