故书不厌百回读，熟读深思子自知——宋.苏轼《送安惊落第诗》

小弟初学安卓，该文算是小弟的学习过程，网络摘抄的概念，课后笔记与一些自己的思考，希望在自己的自学路上留下印记，也许有一些自己想的不对的地方，希望各位前辈斧正。（学了快两个月啦还是感觉自己很菜啊）

一、什么是进程

进程的概念要是我没查过资料的话我肯定会说是“正在进行的程序”，结果这还真的是它的狭义定义，这个很多人在没学习开发程序之前知道进程这个词肯定是在“任务管理器”中。有时候在我们发现运行的程序无响应的时候就会呼出任务管理器来结束进程。

WIN10的任务管理器

二、在安卓中使用多进程

使用多进程的好处那就是由于内存空间独立能够让我们程序更加安全稳定啦，但是多开一个进程开销比开一个线程要高，但因为线程之间可能共享内存会互相影响，有时无法达到我们想要的效果。　　　　
　　想让我们的安卓程序中的组件成为一个进程步骤倒是很简单，只需要在AndroidManifest.xml文件中你希望让其成为单独进程的组件里写下“android:process="xxxxx”就行，注意的是如果你是在双引号中以“：”——冒号开头的话，则会成为application的子进程，application的进程名默认为包名，你也可以在其中加入“android:process="xxxxx”改为自定义的进程名。在谷歌开发文档里发现不同应用的组件还可以在同一进程中，但前提是这些应用共享相同的 Linux 用户 ID 并使用相同的证书进行签署（原话）。

<!--使这个服务成为单独的一个进程--> 
<service android:process="com.qdf.AIDLService" 
android:name=".aidl.AIDLService" android:enabled="true" 
android:exported="true"> 
</service>

与平时使用安卓手机相同，当手机内存不足时，Android系统可能会将我们的某些进程关闭（讲道理好烦啊，我手机有时候就弹出来看个短信再回去就又要重新启动了，明明内存还很足），但Android系统会根据我们的进程重要程度来进行裁决，这其中就牵涉到一个进程的优先级的问题，而谷歌开发文档也列出了进程的重要性层级，共五层：　　
1.前台进程　　　　
　　因为是最重要，可想而知Android系统肯定不会首先去关闭它，因为前台进程一般都是一些正在与用户进行交互的Activity啊，设置了前台运行的Service啊，正在执行onReceive()方法的BroadcastReceiver啊之类，正执行一个生命周期回调的 Service（onCreate()、onStart() 或 onDestroy()）,还有大部分系统进程，基本可以理解，前台进程都是一些如果让Android系统去关闭就会造成不太良好使用体验的进程，所以要将它们列为最高级。

2.可见进程　　　　
　　也挺重要，稍逊前台进程，没有任何前台组件、但仍会影响用户在屏幕上所见内容的进程。谷歌举得例子就是一个显示了Dialog的失去了焦点的Activity(Activity在后面看着你哦~)，想想也是，要是支付宝弹出付款确定对话框，结果Activity的进程就被关掉了那不是很尴尬？　
　　　
3.服务进程　　　　
　　（官方原话）正在运行已使用 startService() 方法启动的服务且不属于上述两个更高类别进程的进程。尽管服务进程与用户所见内容没有直接关联，但是它们通常在执行一些用户关心的操作（例如，在后台播放音乐或从网络下载数据）。因此，除非内存不足以维持所有前台进程和可见进程同时运行，否则系统会让服务进程保持运行状态。　　我的理解就是一个没有被设置为前台进程但却正在正在正在！勤勤恳恳的干事的服务，它这个“齿轮”要是停止工作影响当然是很大的。　　
　　
4.后台进程　　　　
　　处于后台不可见进程，一般是已经做完了自己该做的事了的进程，终止后不会有明显的影响。（官方原话）通常会有很多后台进程在运行，因此它们会保存在 LRU （最近最少使用）列表中，以确保包含用户最近查看的 Activity 的进程最后一个被终止。如果某个 Activity 正确实现了生命周期方法，并保存了其当前状态，则终止其进程不会对用户体验产生明显影响，因为当用户导航回该 Activity 时，Activity 会恢复其所有可见状态。 有关保存和恢复状态的信息，请参阅Activity文档。

5.空进程　　　　
　　（官方原话）不含任何活动应用组件的进程。保留这种进程的的唯一目的是用作缓存，以缩短下次在其中运行组件所需的启动时间。 为使总体系统资源在进程缓存和底层内核缓存之间保持平衡，系统往往会终止这些进程。　　
　　此外，一个进程的级别可能会因其他进程对它的依赖而有所提高，即服务于另一进程的进程其级别永远不会低于其所服务的进程。 例如，如果进程 A 中的内容提供程序为进程 B 中的客户端提供服务，或者如果进程 A 中的服务绑定到进程 B 中的组件，则进程 A 始终被视为至少与进程 B 同样重要。　
　
　　(官方原话)由于运行服务的进程其级别高于托管后台 Activity 的进程，因此启动长时间运行操作的 Activity 最好为该操作启动服务，而不是简单地创建工作线程，当操作有可能比 Activity 更加持久时尤要如此。例如，正在将图片上传到网站的 Activity 应该启动服务来执行上传，这样一来，即使用户退出 Activity，仍可在后台继续执行上传操作。使用服务可以保证，无论 Activity 发生什么情况，该操作至少具备“服务进程”优先级。 同理，广播接收器也应使用服务，而不是简单地将耗时冗长的操作放入线程中。

三、进程间通信

Android 利用远程过程调用 (RPC) 提供了一种进程间通信 (IPC) 机制，通过这种机制，由 Activity 或其他应用组件调用的方法将（在其他进程中）远程执行，而所有结果将返回给调用方。这就要求把方法调用及其数据分解至操作系统可以识别的程度，并将其从本地进程和地址空间传输至远程进程和地址空间，然后在远程进程中重新组装并执行该调用。 然后，返回值将沿相反方向传输回来。 Android 提供了执行这些 IPC 事务所需的全部代码，因此您只需集中精力定义和实现 RPC 编程接口即可。要执行 IPC，必须使用 bindService() 将应用绑定到服务上。—来自官方文档

1.使用Messenger

这是一个Google比较推荐我们使用的类，使用方法倒也并不难，下面是服务类的代码，我已经在AndroidManifest.xml文件中给这个service添加了android:process属性了，然后实例化了Messenger需要我们传入一个Handler(我这里简单创建了一个继承Handler的内部类，其实也可以直接写一个匿名的Handler对象，不过都会有警告，实际上为了防止内存泄漏， 这些写法都不对，这里就先不这么讲究了)

import android.app.Service;
import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.Messenger;
import android.util.Log;


public class MessengerService extends Service {
    //这个服务单独一个进程
    private Messenger mMessenger = new Messenger(new IncomingHandler());

    class IncomingHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            switch (msg.what) {
                case 0:
                    Bundle bundle = msg.getData();
                    Log.i("MS-", "HELLO MESSENGER    " + bundle.get("str"));
                    break;
            }
        }
    }



    @Override
    public IBinder onBind(Intent intent) {
        return mMessenger.getBinder();
    }
}

可以看到onBind方法中返回的Binder是通过Messenger的getBinder()获得的。然后是Activity的代码：

import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.IBinder;
import android.os.Message;
import android.os.Messenger;
import android.os.Parcel;
import android.os.Parcelable;
import android.os.RemoteException;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;

import com.qdf.geekband_eighth_week.R;

public class MessengerActivity extends AppCompatActivity {
    //这个活动处于主进程
    private Messenger mMessenger;
    private ServiceConnection mServiceConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
            mMessenger = new Messenger(iBinder);
            Log.i("MA-", "onServiceConnected");

        }

        @Override
        public void onServiceDisconnected(ComponentName componentName) {
            mMessenger = null;
        }
    };

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_messenger);
        Log.i("MA-", "onCreate");
        Button sendButton = (Button) findViewById(R.id.btn_send);
        sendButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                if (mMessenger!=null) {
                    Log.i("MA-", "not null");
                    Message message = Message.obtain(null, 0, 0, 0);
                    Bundle data=new Bundle();
                    data.putString("str","Hello");
                    message.setData(data);
                    /**
                     * 进程间传递的Message，Message.obj中存放的必须是实现了Parcelable接口的对象，
                     * 否则无法实现IPC!!!!!!重要的事情说三遍！！！
                     */
                    try {
                        mMessenger.send(message);
                        Log.i("MA-", "send");
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                }
            }
        });

    }

    @Override
    protected void onStart() {
        super.onStart();
        bindService(new Intent(this, MessengerService.class), mServiceConnection, Context.BIND_AUTO_CREATE);
        Log.i("MA-", "bindService");


    }


    @Override
    protected void onDestroy() {
        super.onDestroy();
        unbindService(mServiceConnection);
    }
}

在onServiceConnected中我们通过传过来的Bindler在Activity中获得了可以向service发送message的Messenger了，而我们发送的message将由之前在service中实例化的Messenger参数里传入的Handler来处理，这里要说明的是这个Message使用起来与我们Handler发送Message有点不同，主要在这个message.obj的使用上，我们并不是能随心所欲的传我们想传的对象了，它要求我们必须使用实现了Parcelable接口的对象，小弟折腾了一下，也传递了实现了Parcelable接口的对象，还是有点小错误，暂时还没摸清门路，但是如果想传String之类的对象，可以使用Bundle。

现在Activity能向Service发送，那Service要怎么向Activity中发送消息呢？我们假设把创建于服务而用来向服务发送消息的Messenger称为SMessenger，而创建于Activity并用来向Activity的Messenger称为AMessenger。Message类中有一个message.relyto，它允许我们存放Messenger,为了让Service能发送信息给Activity，我们在Activity中创建了AMessenger，将其放入message.relyto，我们可以在Activity刚接受到SMessenger时就马上发送消息将这个message.relyto发给Service，让其在SMessenger的Handler中处理使Service新建Messenger来引用AMessenger，这样，就达成了服务与活动的互相通信了。

2.AIDL

由于在服务中，Messenger将收到的消息放在消息队列中，所以它的处理是同步的，而当我们想在Service中处理多线程的时候，就需要用到AIDL了。
　　操作步骤：
⑴在Module/src/main中首先创建一个aidl目录，并使用NEW->AIDL，会生成一个初始的AIDL文件，我们接着要build或者run一下，这样才能在build/generated/source/aidl/debug/package_name/下生成我们将要用到的java接口。注意，我们不能在这个接口文件你直接编辑，AS也提醒了我们，当我们想要添加方法时，应该在aidl文件中添加声明。void basicTypes的参数告诉了我们方法返回值可使用的基本类型。

接口

创建AIDL文件

// IMyAidlInterface.aidl
package com.XXXXX;

// Declare any non-default types here with import statements

interface IMyAidlInterface {
    /**
     * Demonstrates some basic types that you can use as parameters
     * and return values in AIDL.
     */
    void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat,
            double aDouble, String aString);
    String getName(String nickName);//自己声明的方法
}

(2)此时AIDL已构建完成，如果我们想加入新方法只需再编辑再build一次就好了，现在，我们要在Service中实现接口，下面是一个Activity和一个Service的简单代码。

AIDLService.java

package com.qdf.geekband_eighth_week.aidl;

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.os.RemoteException;

import com.qdf.geekband_eighth_week.IMyAidlInterface;

public class AIDLService extends Service {

    IMyAidlInterface.Stub myStub = new IMyAidlInterface.Stub() {
        @Override
        public void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat, double aDouble, String aString) throws RemoteException {

        }

        @Override
        public String getName(String nickName) throws RemoteException {
            return "AIDL HAHAHA" + nickName;
        }

        @Override
        public int getInt(int age) throws RemoteException {
            return 0;
        }
    };

    public AIDLService() {
    }

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

可以看到我们实现接口是实例化了接口中的Stub内部类，该类继承了Binder（由此可知我们为什么必须使用bindService了），并又同时实现了IMyAidlInterface（接口文件默认名，可更改）。可以看到，当我们实例化后就能看到它会要求我们实现我们在aidl文件中声明的方法。而在onBind()方法里最后返回的是stub（继承自Binder嘛）。

AIDLActivity.java

package com.qdf.geekband_eighth_week.aidl;

import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.IBinder;
import android.os.RemoteException;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;

import com.qdf.geekband_eighth_week.IMyAidlInterface;
import com.qdf.geekband_eighth_week.R;

public class AIDLActivity extends AppCompatActivity {

    private Button mTestButton;
    private IMyAidlInterface mIMyAidlInterface;
    private ServiceConnection mServiceConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
             mIMyAidlInterface = IMyAidlInterface.Stub.asInterface(service);
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {

        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_aidl);
        mTestButton = (Button) findViewById(R.id.btn_test);
        mTestButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                if (mIMyAidlInterface != null) {
                    try {
                        String name = mIMyAidlInterface.getName("qdf");
                        Toast.makeText(AIDLActivity.this, name + "", Toast.LENGTH_SHORT).show();
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        bindService(new Intent(this, AIDLService.class), mServiceConnection, Context.BIND_AUTO_CREATE);
    }

}

在Activity中，则声明接口对象而不是接口.Stub对象了，在连接服务后，接收到的IBinder利用Stub的asInrerdace方法将其转为接口对象。使用上，相比Messenger，AIDL感觉使用起来更方便，我们只需使用接口对象调用之前写在Service中的Stub方法，而Stub在服务中又可以轻易调用我们定义在服务中的方法，可以很方便的完成进程通信。