Android-HandlerThread

在外部线程并不能拿到匿名内部类线程对象的Looper。比如主线程，创建了一个Thread对象，并不能通过Thread对象获取到该Thread的Looper对象。
而如果将Thread的Looper写全局对象，那么就存在耦合，并不会随着线程Thread的消失而消失。
HandlerThread就是一个线程。在HandlerThread中的run方法中，自动帮我们完成了Looper.prepare和Looper.loop()。
HandlerThread存在的意义主要是：
方便初始化，方便取线程Looper对象
保证了线程安全
解决有可能的异步问题。
面试：多线程的锁机制。
当有人通过HandlerThread的getLooper()方法获取线程对应的Looper对象的时候，如果Looper对象为null，那么就会调用wait()等待。而在HandlerThread的run方法中，如果Looper.prepare()成功之后，就会调用notifyAll()通知需要获取锁。
wait()：会释放锁
notifyAll()：不会释放当前持有的锁，只是会唤醒其他等待这个锁的线程，但是并不意味着会立马执行，需要等待notifyAll()所在的锁中的代码执行完成并且释放锁之后，被唤醒的其他线程去持有锁并且继续执行。

HandlerThread的应用：在IntentService中
IntentService初始化之后，实现onHandleIntent方法，而在IntentService中处理Handler消息的时候，就是调用onHandleIntent方法进行处理。
而IntentService就是可以在Service中实现耗时操作，其实就是在其内部有一个ServiceHandler，而ServiceHandler的创建，就是通过HandlerThread对象获取到子线程的Looper对象，然后创建了ServiceHandler对象。
IntentService.ServiceHandler源码：

private final class ServiceHandler extends Handler {
    public ServiceHandler(Looper looper) {
        super(looper);
    }

    @Override
    public void handleMessage(Message msg) {
        onHandleIntent((Intent)msg.obj);
        // 处理消息之后，停止Service，自己停止自己。
        stopSelf(msg.arg1);
    }
}

IntentService.onCreate()源码：

@Override
public void onCreate() {
    // TODO: It would be nice to have an option to hold a partial wakelock
    // during processing, and to have a static startService(Context, Intent)
    // method that would launch the service & hand off a wakelock.

    super.onCreate();
    HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
    thread.start();

    mServiceLooper = thread.getLooper();
    // 创建子线程HandlerThread对象的Handler
    mServiceHandler = new ServiceHandler(mServiceLooper);
}

Service一般用于处理后台耗时任务。
IntentService会维持一个子线程独有的消息队列，保证每一个任务都是在同一个线程。这样就可以保证在IntentService一定是处理的同一个线程的任务。这样就可以保证任务在同一个线程中按照先后顺序执行。
应用需求：一项任务分成几个子任务，子任务按顺序先后执行，子任务全部执行完成之后，这项任务才算成功。
这个需求可以用多个线程来处理，一个线程处理完->下一个线程->下一个线程
IntentService也可以帮助我们实现这个需求。而且，能够很好的管理线程，保证只有一个子线程处理工作，而且是一个一个的完成任务，有条不紊的进行对多个子任务的处理。
IntentService的使用：

public class MyIntentService extends IntentService {

  /** 
    * 在构造函数中传入线程名字
    **/  
    public myIntentService() {
        // 调用父类的构造函数
        // 参数 = 工作线程的名字
        super("myIntentService");
    }

   /** 
     * 复写onHandleIntent()方法
     * 根据 Intent实现 耗时任务 操作
     **/  
    @Override
    protected void onHandleIntent(Intent intent) {

        // 根据 Intent的不同，进行不同的事务处理
        String taskName = intent.getExtras().getString("taskName");
        switch (taskName) {
            case "task1":
                Log.i("myIntentService", "do task1");
                break;
            case "task2":
                Log.i("myIntentService", "do task2");
                break;
            default:
                break;
        }
    }

    @Override
    public void onCreate() {
        Log.i("myIntentService", "onCreate");
        super.onCreate();
    }
   /** 
     * 复写onStartCommand()方法
     * 默认实现 = 将请求的Intent添加到工作队列里
     **/  
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.i("myIntentService", "onStartCommand");
        return super.onStartCommand(intent, flags, startId);
    }

    @Override
    public void onDestroy() {
        Log.i("myIntentService", "onDestroy");
        super.onDestroy();
    }
}

在AndroidManifest.xml中注册

<service android:name=".myIntentService">
            <intent-filter >
                <action android:name="cn.scu.finch"/>
            </intent-filter>
        </service>

在Activity中启动IntentService

public class MainActivity extends AppCompatActivity {

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

            // 同一服务只会开启1个工作线程
            // 在onHandleIntent（）函数里，依次处理传入的Intent请求
            // 将请求通过Bundle对象传入到Intent，再传入到服务里

            // 请求1
            Intent i = new Intent("cn.scu.finch");
            Bundle bundle = new Bundle();
            bundle.putString("taskName", "task1");
            i.putExtras(bundle);
            startService(i);

            // 请求2
            Intent i2 = new Intent("cn.scu.finch");
            Bundle bundle2 = new Bundle();
            bundle2.putString("taskName", "task2");
            i2.putExtras(bundle2);
            startService(i2);

            startService(i);  //多次启动
        }
    }

除了在IntentService使用HandlerThread以外：
（1）在Fragment的生命周期管理
Fragment一般是通过FragmentManager事务提交，而提交的时候，是通过Handler发送消息执行提交过程。
FragmentManager中使用了Handler进行提交。

void scheduleCommit() {
    synchronized (this) {
        boolean postponeReady =
                mPostponedTransactions != null && !mPostponedTransactions.isEmpty();
        boolean pendingReady = mPendingActions != null && mPendingActions.size() == 1;
        if (postponeReady || pendingReady) {
            mHost.getHandler().removeCallbacks(mExecCommit);
            mHost.getHandler().post(mExecCommit);
        }
    }
}

（2）在Glide的生命周期管理也使用了类似的方式，即创建一个空的Fragment管理生命周期，如果Fragment是空的时候，先从缓存去中，如果缓存中还是空的，则重新创建一个新的Fragment，这里使用缓存的目的，是因为Fragment事务提交的时候，是通过Handler发送消息提交事务，而这个任务并不一定是立马执行，也不一定是在下一次任务来的时候就已经提交完成，因为Glide可以多线程使用。当一个线程使用创建了空的Fragment生命周期管理，那么下一个线程异步请求创建空的生命周期管理的时候，先去查询一个临时HashMap缓存，这是因为Fragment事务提交是Handler发送消息，并不能保证立马执行完成，而在临时HashMap缓存一个空的Fragment生命周期，然后经过两次的判空，而空的Fragment就算没有绑定，那么也会先在缓存中存在这个对象，那么第二个线程进来之后就不会去创建这个空的Fragment生命周期管理。

@NonNull
private RequestManagerFragment getRequestManagerFragment(
    @NonNull final android.app.FragmentManager fm,
    @Nullable android.app.Fragment parentHint,
    boolean isParentVisible) {
  RequestManagerFragment current = (RequestManagerFragment) fm.findFragmentByTag(FRAGMENT_TAG);
  if (current == null) {
    current = pendingRequestManagerFragments.get(fm);
    if (current == null) {
      current = new RequestManagerFragment();
      current.setParentFragmentHint(parentHint);
      if (isParentVisible) {
        current.getGlideLifecycle().onStart();
      }
      pendingRequestManagerFragments.put(fm, current);
      fm.beginTransaction().add(current, FRAGMENT_TAG).commitAllowingStateLoss();
      handler.obtainMessage(ID_REMOVE_FRAGMENT_MANAGER, fm).sendToTarget();
    }
  }
  return current;
}