Android成长笔记。android基础巩固和提升多线程

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

2017-04-02  本文已影响175人  博儿丶

目录

前言
  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、简介特点

2、主要责任

3、特别规定（必须遵循）

//产生耗时操作
bt1.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                try {
                    // 让UI线程睡上20s
                    Thread.sleep(20000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
ANR 
        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、知识扩展

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简述

//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、相关概念

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

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）常规用法

（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的特点

【附录】

Demo

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

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

3、HandlerThread 总结使用

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

上一篇 下一篇

猜你喜欢

热点阅读