20171126--handlerThread

1.首先看下handlerThread和普通的线程Thread的使用区别：

HandlerThread本质上就是一个普通Thread,只不过内部建立了Looper.

为线程创建Looper的方法如下：在线程run()方法当中先调用Looper.prepare()初始化Looper,然后再run()方法最后调用Looper.loop()，这样我们就在该线程当中创建好Looper。(注意：Looper.loop()方法默认是死循环)  我们实现Looper有没有更加简单的方法呢?当然有，这就是我们的HandlerThread

public class MainActivity extends Activity {

    /**
     *
     * 程序说明：
     *     UI Thread 通过handler向其他线程发送数据并进行打印
     *
     */

    private Handler superHandler;
    private Handler normalHandler;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        NormalThread normalThread = new NormalThread();
        normalThread.start();

        HandlerThread handlerThread = new HandlerThread("leochin.com");
        handlerThread.start();

        /*
         * 将handlerThread中创建的looper传递给Handler。
         *
         * 也就意味着该Handler收到Message后，程序在HandlerThread创建的线程中运行
         *
         */
        superHandler = new Handler(handlerThread.getLooper()){

            @Override
            public void handleMessage(Message msg) {
                // TODO Auto-generated method stub
                super.handleMessage(msg);

                int what = msg.what;

                if(what == 2){
                    Log.d("wenhao",Thread.currentThread().getName()+" HandlerThread is OK");
                }
            }
        };
    }

    /**
     *
     * 普通线程
     *
     */
    class NormalThread extends Thread{

        @Override
        public void run() {
            // TODO Auto-generated method stub

            Looper.prepare();

            normalHandler = new Handler(){

                @Override
                public void handleMessage(Message msg) {
                    // TODO Auto-generated method stub
                    super.handleMessage(msg);

                    int what = msg.what;

                    if(what == 1){
                        Log.d("wenhao",Thread.currentThread().getName()+ " NormalThread is OK");
                    }
                }

            };

            Looper.loop();
        }

    }

    /**
     *
     * 向普通线程发送数据
     *
     * @param view
     */
    public void normalThreadUse(View view){

        if(normalHandler == null){
            return;
        }

        normalHandler.sendEmptyMessage(1);
    }

    /**
     *
     * 向HandlerThread发送数据
     *
     * @param view
     */
    public void handlerThreadUse(View view){

        if(superHandler == null){
            return;
        }

        superHandler.sendEmptyMessage(2);
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.main, menu);
        return true;
    }

}

2.handler和handlerThread的区分：

参考博客：http://www.mamicode.com/info-detail-1612038.html

3.handler使用场景：HandlerThread比较适用于单线程+异步队列的场景，比如IO读写操作，耗时不多而且也不会产生较大的阻塞。对于网络IO操作，HandlerThread并不适合，因为它只有一个线程，还得排队一个一个等着。

HandlerThread的特点

• HandlerThread将loop转到子线程中处理，说白了就是将分担MainLooper的工作量，降低了主线程的压力，使主界面更流畅。
• 开启一个线程起到多个线程的作用。处理任务是串行执行，按消息发送顺序进行处理。
  相比多次使用new Thread(){…}.start()这样的方式节省系统资源。
  但是由于每一个任务都将以队列的方式逐个被执行到，一旦队列中有某个任务执行时间过长，那么就会导致后续的任务都会被延迟处理。
• HandlerThread拥有自己的消息队列，它不会干扰或阻塞UI线程。
• 通过设置优先级就可以同步工作顺序的执行，而又不影响UI的初始化；

4.具体使用：

import android.os.Bundle;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Message;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;

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() ;
    }
}

5.

6.

7.