当作笔记记忆一下

public class BasePresenter<V extends BaseView,M extends BaseModel>{

    private M mModel;

    public void attach(){

          //1、返回表示此 Class 所表示的实体（类、接口、基本类型或 void）的直接超类的 Type
        Type genType = getClass().getGenericSuperclass();
        //2、泛型参数
        Type[] types = ((ParameterizedType) genType).getActualTypeArguments();
        //3、因为BasePresenter 有两个泛型 数组有两个
        try {
            //
            mModel= (M) ((Class)types[1]).newInstance();
            //这里需要强转得到的是实体类类路径
//            如果types[1].getClass().newInstance();并不行，得到的是泛型类型
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    public M getModel(){

        return mModel;
    }

}

Android 基于Linux，而所有的进程都基于init进程。 。

当系统开机时，就会由init进程fork出Zygote进程，它时Android系统中第一个Dalvik虚拟机上的第一个进程，同时负责卵化其他apk的进程。

SystemServer进程，Android系统的第二大进程，也是一个非常重要的进程，它本身也是由Zygote进程卵化出来的。

在ZygoteInit的main方法

public static void main(String argv[]) {
       ....
        try {
        ....
            boolean startSystemServer = false;
            String socketName = "zygote";
            String abiList = null;
            boolean enableLazyPreload = false;
            //第一次fork出Zygote时，会让startSystemServer为 true，来开启SystemServer进程
            for (int i = 1; i < argv.length; i++) {
                if ("start-system-server".equals(argv[i])) {
                    startSystemServer = true;
                } else if ("--enable-lazy-preload".equals(argv[i])) {
                    enableLazyPreload = true;
                } else if (argv[i].startsWith(ABI_LIST_ARG)) {
                    abiList = argv[i].substring(ABI_LIST_ARG.length());
                } else if (argv[i].startsWith(SOCKET_NAME_ARG)) {
                    socketName = argv[i].substring(SOCKET_NAME_ARG.length());
                } else {
                    throw new RuntimeException("Unknown command line argument: " + argv[i]);
                }
            }
          ....
            //开启SystemServer进程
            if (startSystemServer) {
                startSystemServer(abiList, socketName, zygoteServer);
            }

            zygoteServer.runSelectLoop(abiList);

            zygoteServer.closeServerSocket();
        } catch (Zygote.MethodAndArgsCaller caller) {
            caller.run();
        } catch (Throwable ex) {
            Log.e(TAG, "System zygote died with exception", ex);
            zygoteServer.closeServerSocket();
            throw ex;
        }
    }

IntentService是继承Service的抽象类，一般用于执行后台耗时任务，当任务执行完毕之后，会自动停止。

源码依然比较简单

public abstract class IntentService extends Service {
    private volatile Looper mServiceLooper;
    private volatile ServiceHandler mServiceHandler;
    private String mName;
    private boolean mRedelivery;

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

        @Override
        public void handleMessage(Message msg) {
            onHandleIntent((Intent)msg.obj);
            stopSelf(msg.arg1);
        }
    }


    public IntentService(String name) {
        super();
        mName = name;
    }


    public void setIntentRedelivery(boolean enabled) {
        mRedelivery = enabled;
    }

    @Override
    public void onCreate() {

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

        mServiceLooper = thread.getLooper();
        mServiceHandler = new ServiceHandler(mServiceLooper);
    }

    @Override
    public void onStart(@Nullable Intent intent, int startId) {
        Message msg = mServiceHandler.obtainMessage();
        msg.arg1 = startId;
        msg.obj = intent;
        mServiceHandler.sendMessage(msg);
    }


    @Override
    public int onStartCommand(@Nullable Intent intent, int flags, int startId) {
        onStart(intent, startId);
        return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
    }

    @Override
    public void onDestroy() {
    //出队
        mServiceLooper.quit();
    }


    @Override
    @Nullable
    public IBinder onBind(Intent intent) {
        return null;
    }


    @WorkerThread
    protected abstract void onHandleIntent(@Nullable Intent intent);

IntentService第一次启动，会调用OnCreate方法，会先创建一个HandlerThread，接着将它的Looper对象传入给Handler对象，构造出一个mServiceHandler。

每次startService，都会调用onStartCommand方法，代码中，会调用onStart(intent, startId)，通过这个方法，把intent和startId 传递给mServiceHandler来执行。

这里是通过一个抽象方法把intent传递给子类来自定义实现。执行完毕，会调用stopSelf(int startId),这里有必要注意一下，之所以调用stopSelf(int startId)，而不是stopSelf()，因为stopSelf()会立刻停止服务，而这个时候，还有可能别的消息未处理，而stopSelf(int startId)则会等待所有消息执行结束之后才终止服务。

同时，因为采用的Handler方式，而且没执行一个后台任务，都要启动一次IntentService，这也就意味着IntentService是顺序执行后台请求的。

最后，在OnDestroy中，调用quit方法，清空MessageQueue队列。

HandlerThread 其实就是一个普通的Thread，唯一不同的是可以使用Handler的Thread。

举个例子

  mHandlerThread = new HandlerThread("handler_thread");
        mHandlerThread.start();

        mHandler = new Handler(mHandlerThread.getLooper()){
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                //这里是子线程 线程名称handler_thread
                Log.d("AAA",Thread.currentThread().getName());

            }
        };

        Log.d("AAA",Thread.currentThread().getName());


    new Thread(new Runnable() {
        @Override
        public void run() {
            mHandler.sendEmptyMessageDelayed(1,3000);
        }
    }).start();
    }

    @Override
    public void onClick(View v) {

        mHandler.sendMessage(Message.obtain());
    }

     @Override
    protected void onDestroy() {
        super.onDestroy();
        mHandlerThread.quit();
    }

打印的结果

main
handler_thread
handler_thread

无论是主线程还是子线程，都可以把消息发送给mHandler的handleMessage处理，值得注意的是，mHandler虽然实在主线程创建了实例，但是handleMessage方法却是运行在子线程。

实现原理很简单，跟之前 Android消息机制（四）—Handler分析中的原理一样，根据一个Thread对应一个Looper来实现。

看run方法

 @Override
    public void run() {
        mTid = Process.myTid();
        Looper.prepare();
        synchronized (this) {
            mLooper = Looper.myLooper();
            notifyAll();
        }
        Process.setThreadPriority(mPriority);
        onLooperPrepared();
        Looper.loop();
        mTid = -1;
    }

在run方法发中创建了Looper，开启了loop，无限循环，所以只需要将该looper设置给handler，就会将消息添加到当前Looper对应Thread的MessageQueue中。

  public Handler(Looper looper, Callback callback, boolean async) {
        mLooper = looper;
        mQueue = looper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }

AsyncTask的使用

• AsyncTask是对Thread和Handler的封装，它在线程池中执行后台任务，然后把任务的进度和最终结果传递给UI线程处理。
• AsyncTask并不适合非常耗时的任务（也就几分钟），如果是非常耗时的操作，还是使用Executor等线程池。
• AsyncTask 是一个抽象的类，有三个泛型，Params、Progress、Result。Params表示传入参数的类型，Progress表示后台任务执行的进度类型，Rsult表示后台任务的返回结果的类型，如果不需要传递具体类型，可以传递Void。

  四个核心的方法。

• onPreExecute()，在UI线程中执行，在异步任务执行之前调用。
• doInBackground(Params…params)，在线程池中执行，用于执行异步任务。调用publishProgress方法，会调用onProgressUpdate方法。
• onProgressUpdate(Progress…values)方法在UI线程调用，一般用做更新进度条。
• onPostExecute(Result result)，result是doInBackground的返回值，在Ui线程执行。