一般情况下，一个应用程序就是一个进程，这个进程名称就是应用程序包名。我们知道进程是系统分配资源和调度的基本单位，所以每个进程都有自己独立的资源和内存空间，别的进程是不能任意访问其他进程的内存和资源的。
有不少人疑惑，Android为什么要用多进程？用多进程的优点？缺点？
好处：
（1）分担主进程的内存压力。
当应用越做越大，内存越来越多，将一些独立的组件放到不同的进程，它就不占用主进程的内存空间了。当然还有其他好处，有心人会发现
（2）使应用常驻后台，防止主进程被杀守护进程，守护进程和主进程之间相互监视，有一方被杀就重新启动它。
Android后台进程里有很多应用是多个进程的，因为它们要常驻后台，特别是即时通讯或者社交应用，不过现在多进程已经被用烂了。
典型用法是在启动一个不可见的轻量级私有进程，在后台收发消息，或者做一些耗时的事情，或者开机启动这个进程，然后做监听等。
坏处：
消耗用户的电量。 多占用了系统的空间，若所有应用都这样占用，系统内存很容易占满而导致卡顿。应用程序架构会变得复杂，因为要处理多进程之间的通信。这里又是另外一个问题了。
多进程的缺陷
进程间的内存空间是不可见的。开启多进程后，会引发以下问题：
1）Application的多次重建。
2）静态成员的失效。
3）文件共享问题。
4）断点调试问题。
在了解了多进程的优缺点之后，接下来介绍使用的方法。
四大组件在AndroidManifest文件中注册的时候，有个属性android:process这里可以指定组件的所处的进程。
默认就是应用的主进程。指定为别的进程之后，系统在启动这个组件的时候，就先创建（如果还没创建的话）这个进程，然后再创建该组件。打印出它的进程名称：重
载Application类的onCreate方法即可。
设置android:process属性，要注意：如果是android:process=”:comm”，以:开头的名字，表示这是一个应用程序的私有进程，否则它是一个全局进程。私有进程的进程名称是
会在冒号前自动加上包名，而全局进程则不会。一般我们都是有私有进程，很少使用全局进程。
首先创建一个WheatherService：
public class WheatherService extends Service {
private RemoteCallbackList<IMyAidlCallBack> mRemoteCallbackList = new RemoteCallbackList<>();
@Nullable
@Override
public IBinder onBind(Intent intent) {
return new WheatherBinder();
}
private void getWheather() {
OkHttpUtils.get()
.url("http://www.apiopen.top:88/weatherApi?city=%E5%8E%A6%E9%97%A8")
.build()
.execute(new StringCallback() {
@Override
public void onError(Call call, Exception e, int id) {
log(e.toString());
final int count = mRemoteCallbackList.beginBroadcast();
if (count == 0) {
return;
}
try {
for (int i = 0; i < count; i++)
mRemoteCallbackList.getBroadcastItem(i).onError(e.toString());
} catch (RemoteException e1) {
log(e1.toString());
}
mRemoteCallbackList.finishBroadcast();
}
@Override
public void onResponse(String response, int id) {
log(response);
final int count = mRemoteCallbackList.beginBroadcast();
if (count == 0) {
return;
}
try {
for (int i = 0; i < count; i++)
mRemoteCallbackList.getBroadcastItem(i).onSuccess(JSON.parseObject(response, Wheather.class));
} catch (RemoteException e) {
e.printStackTrace();
}
mRemoteCallbackList.finishBroadcast();
}
});
}
private void log(String value) {
Log.e("TAG", value);
}
class WheatherBinder extends IRemoteService.Stub {
private IMyAidlCallBack iMyAidlCallBack;
@Override
public void getWheather() throws RemoteException {
log("getWheather-----------------");
WheatherService.this.getWheather();
}
@Override
public void registerListener(IMyAidlCallBack callBack) throws RemoteException {
this.iMyAidlCallBack = callBack;
log("registerListener");
if (mRemoteCallbackList == null) {
log("mRemoteCallbackList==null");
return;
}
mRemoteCallbackList.register(callBack);
}
@Override
public void unRegisterListener(IMyAidlCallBack callBack) throws RemoteException {
mRemoteCallbackList.unregister(callBack);
}
}
}
在AndroidManifest问见中注册这个service：
<service
android:name=".WheatherService"
android:process=":comm">
<intent-filter>
<action android:name="com.zlx.crossprocommut.IRemoteService" />
</intent-filter>
</service>
在我们的MainActivity中进行服务的绑定：
public class MainActivity extends AppCompatActivity {
private TextView tv;
private IRemoteService iRemoteService;
private IMyAidlCallBack mCallBack = new IMyAidlCallBack.Stub() {
@Override
public void onSuccess(final Wheather wheather) throws RemoteException {
log("value: " + wheather.toString());
tv.post(new Runnable() {
@Override
public void run() {
Wheather.DataBean data = wheather.getData();
tv.setText("City："+data.getCity() + "\n" + "Cityid: "+data.get+"温度："+data.getWendu()+".....................");
}
});
}
@Override
public void onError(String error) throws RemoteException {
log("value: " + error);
}
};
private ServiceConnection connection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName componentName, final IBinder iBinder) {
iRemoteService = WheatherService.WheatherBinder.asInterface(iBinder);
show("Service Connected！");
log("Service Connected！");
try {
iRemoteService.registerListener(mCallBack);
} catch (RemoteException e) {
e.printStackTrace();
}
}
@Override
public void onServiceDisconnected(ComponentName componentName) {
show("Service Disconnected！");
log("Service Disconnected！");
iRemoteService = null;
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
tv = findViewById(R.id.id_tv);
}
@Override
protected void onStart() {
super.onStart();
Intent intent = new Intent(this, WheatherService.class);
intent.setAction("com.zlx.crossprocommut.IRemoteService");
intent.setPackage("com.zlx.crossprocommut");
bindService(intent, connection, Context.BIND_AUTO_CREATE);
}
@Override
protected void onDestroy() {
super.onDestroy();
unbindService(connection);
}
public void getWheather(View view) {
try {
if (iRemoteService != null) {
iRemoteService.getWheather();
}
} catch (Exception e) {
e.printStackTrace();
}
}
private void log(String value) {
Log.e("TAG", value);
}
private void show(String value) {
Toast.makeText(MainActivity.this, value, Toast.LENGTH_SHORT).show();
}
}
有的人会问，这里为什么要用bindService,不用startService？其实这里是看具体情况的哈，如果用bindService：activity销毁，服务也就没了，而用startService：activity销毁，服务仍然还在！
最关键的要创建aidl文件：
IMyAidlCallBack.aidl：
import com.zlx.crossprocommut.Wheather;
interface IMyAidlCallBack {
void onSuccess(in Wheather wheather);
void onError(String error);
}
IRemoteService.aidl：
import com.zlx.crossprocommut.IMyAidlCallBack;
interface IRemoteService {
void getWheather();
void registerListener(IMyAidlCallBack callBack);
void unRegisterListener(IMyAidlCallBack callBack);
}
Wheather.aidl：
parcelable Wheather;
注意：Wheather是一个parcelable 序列化的数据对象
