在子线程中创建Handler和looper并与主线程进行交互

分析完上面那篇文章,基本理解了handler的实现原理,乘热打铁,这里我们利用handler原理,在子线程中创建一个handler和looper

可能很多面试时候问道,子线程中能不能new一个handler ?

答案是可以的,但是因为主线程系统默认在ActivityThread中已将帮我们创建好一个looper和MessagQueue,我们不需要手动去创建

(手动创建会出错,因为一个线程中默认只运行一个looper和MessageQueue,具体见ThreadLocal代码原理),

而子线程中没有looper,我们必须学习ActivityThread中的代码手动创建一个Looper(MessageQueue不用创建,因为它在looper的构造方法中已经默认创建好了)

上代码,子线程类,里面维护了一个looper
1. 　　
  import android.os.Handler;
  import android.os.Looper;
  import android.os.SystemClock;
  /**
  * 子线程looper所在的子线程类
  * @author Administrator
  *
  */
  public class MyLooperThread extends Thread {
  private Looper mLooper;
  int i=5;
  /**
  * MainActivity中handler
  */
  private Handler mHandler;
  /**
  * 构造方法接受主线程的Handler 方便用主线程的handler去发送消息给主线程的looper
  * @param mHandler
  */
  public MyLooperThread(Handler mHandler) {
  super();
  this.mHandler = mHandler;
  }
  private Handler looperThreadHandler=new Handler(){
  public void handleMessage(android.os.Message msg) {
  switch (msg.what) {
  case 1:
  System.out.println("主线程的消息来了....");
  break;
  default:
  //MyThread的线程发送一个0的消息, 执行一个耗时操作
  System.out.println("开始执行耗时操作....");
  SystemClock.sleep(2000);
  SystemClock.sleep(2000);
  if(i>0){
  i-=2;
  System.out.println("耗时操作已完下执行下一个....");
  //不断轮询执行
  looperThreadHandler.sendEmptyMessage(0);
  }else{
  //操作完成发送消息到主线程
  mHandler.sendEmptyMessage(0);
  System.out.println("所有任务已完成,等待ing....");
  }
  break;
  }
  
  };
  };
  
  @Override
  public void run() {
  super.run();
  //初始化一个looper 其构造方法中默认已经
  Looper.prepare();
  synchronized (this) {
  mLooper = Looper.myLooper();
  notifyAll();
  }
  Looper.loop();
  System.out.println("执行了吗");
  
  }
  
  public Looper getmLooper() {
  return mLooper;
  }
  public Handler getHandler() {
  return looperThreadHandler;
  }
  public void setHandler(Handler handler) {
  this.looperThreadHandler = handler;
  }
  
  }
  上面的代码有点长,主要是创建了一个子线程类,然后在其run()方法里面创建一个looper并轮询,构造方法中接受一个主线程的handler,以便于耗时操作完成之后,利用这个handler发送消息给主线程,这里我们可以发现,要想向不同的线程中发消息,必须要获取向对应线程的handler,而handler在哪个线程创建的,就已经和当前线程绑定在一起了

第二个类线程类主要作用是用这个线程去向上面的looper线程发一个消息,启动它的耗时任务

/**
 * 线程类  在子线程中获取looper并发空消息
 * @author MR.wang
 *
 */
public class MyThread extends Thread {

    MyLooperThread looperThread;

    public MyThread(MyLooperThread looperThread) {
        super();
        this.looperThread = looperThread;
    }

    @Override
    public void run() {
        super.run();
        looperThread.getHandler().sendEmptyMessage(0);
        System.out.println("子线程中的执行了吗");
    }
    

}

这个代码相对好理解些,构造方法中接受looper线程中的handler,以便给他发消息,最后在run()方法发个消息,启动looper线程的耗时任务.

第三个类,主线程的hanler所在的类

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.widget.Toast;
/**
 * 主线程类 
 * @author MR.wang
 */
public class MainActivity extends Activity {
    private Handler handler = new Handler() {
        public void handleMessage(android.os.Message msg) {
            //子线程执行耗时操作完成 通知主线程
            Toast.makeText(MainActivity.this, "所有任务已完成", Toast.LENGTH_SHORT)
                    .show();
            //获取子线程的handler并发送一个消息给子线程的looper
            looperThread.getHandler().sendEmptyMessage(1);
        };
    };
    private MyLooperThread looperThread;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //初始化子线程中的looper
        looperThread = new MyLooperThread(handler);
        // 开启子线程中的looper
        looperThread.start();
        //初始化一个子线程 用于给looper所在的子线程发送消息启动它
        MyThread thread = new MyThread(looperThread);
        thread.start();
    }

}

着重看看onCreate方法,初始化一个looper线程,传入当前主线程的handler,然后让另外一个子线程去给looper线程发一个消息,执行耗时任务,looper线程中耗时任务执行完毕,拿着主线程传入的handler给主线程发个消息,最后主线程的handlMessage()方法收到消息,Toast出来,完成了主线程到子线程之间的消息对接

最后总结一下
1. handler创建的时候,就与当前线程绑定起来,要给一个线程发消息,获取到此线程的hanler发送消息即可.
2. 主线程中ActivityThread默认帮我们创建好了一个looper和MessageQueue,因此我们不需要手动创建,若需要在子线程中创建一个handler,则子线程中必须也有一个looper和MessageQueue与之对应,所有,子线程中可以有handler,只需我们手动创建一个looper即可(Messagequeue在looper构造方法中自动创建)
3. 主线程的handlMessage中尽量不要执行任何耗时操作,因为容易造成主线程阻塞(UI线程5秒,服务10秒)
4. handler looper Messagequeue三个组合起来,和线程池特别类似,可以利用此,维护一个类似与线程池的框架,用来处理耗时多线程操作,比如网络下载多个图片等

静以修身俭以养德