Android后台进程的保活

你的名字 2023-07-05 10:26 15阅读 0赞

#### 1、为什么需要对进程进行保活 ####

系统出于体验和性能上的考虑，app在退到后台时系统并不会真正的kill掉这个进程，而是将其缓存起来。打开的应用越多，后台缓存的进程也越多。在系统内存不足的情况下，系统开始依据自身的一套进程回收机制来判断要kill掉哪些进程，以腾出内存来供给需要的app。但是有时候我们想在后台做一些操作就需要对进程进行包活。

#### 2、Android系统对进程的回收机制 ####

Android在内存较低的情况下，会关闭一些优先级较低的进程以增大内存运行更重要的进程，而在这个进程中的所有线程，也会被同时销毁。  
Android中，进程的生命周期都是由系统控制的。即使用户在界面上关掉一个应用，切换到了别的应用，那个应用的进程依然是存在于内存之中的。这样设计的目的是为了下次启动应用能更加快速。当然，随着系统运行时间的增长，内存中的进程可能会越来越多，而可用的内存则将会越来越少。Android Kernel会定时执行一次检查，杀死一些进程，释放掉内存。

Android一般的进程优先级划分：  
1.前台进程 (Foreground process)  
2.可见进程 (Visible process)  
3.服务进程 (Service process)  
4.后台进程 (Background process)  
5.空进程 (Empty process)  
进程其实有一种具体的数值，称作oom\_adj，注意：数值越大优先级越低

#### 3、进程被kill的场景？ ####

（1）.点击home键使app长时间停留在后台，内存不足被kill  
（2）.在大多数国产手机下，进入锁屏状态一段时间，省电机制会kill后台进程

#### 4、保活方案 ####

（1）、开启一个像素的Activity  
据说这个是手Q的进程保活方案，基本思想，系统一般是不会杀死前台进程的。所以要使得进程常驻，我们只需要在锁屏的时候在本进程开启一个Activity，为了欺骗用户，让这个Activity的大小是1像素，并且透明无切换动画，在开屏幕的时候，把这个Activity关闭掉，所以这个就需要监听系统锁屏广播。

public class SinglePixelActivity extends Activity {
    
        public static final String TAG = SinglePixelActivity.class.getSimpleName();
    
        public static void actionToSinglePixelActivity(Context pContext) {
            Intent intent = new Intent(pContext, SinglePixelActivity.class);
            intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
            pContext.startActivity(intent);
        }
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            Log.d(TAG, "onCreate");
            setContentView(R.layout.activity_singlepixel);
            Window window = getWindow();
            //放在左上角
            window.setGravity(Gravity.START | Gravity.TOP);
            WindowManager.LayoutParams attributes = window.getAttributes();
            //宽高设计为1个像素
            attributes.width = 1;
            attributes.height = 1;
            //起始坐标
            attributes.x = 0;
            attributes.y = 0;
            window.setAttributes(attributes);
    
            ScreenManager.getInstance(this).setActivity(this);
        }
    
        @Override
        protected void onDestroy() {
            super.onDestroy();
        }
    }

在屏幕关闭的时候把SinglePixelActivity启动起来，在开屏的时候把SinglePixelActivity 关闭掉，所以要监听系统锁屏广播，以接口的形式通知MainActivity启动或者关闭SinglePixActivity。

public class ScreenBroadcastListener {
    
        private Context mContext;
    
        private ScreenBroadcastReceiver mScreenReceiver;
    
        private ScreenStateListener mListener;
    
        public ScreenBroadcastListener(Context context) {
            mContext = context.getApplicationContext();
            mScreenReceiver = new ScreenBroadcastReceiver();
        }
    
        interface ScreenStateListener {
    
            void onScreenOn();
    
            void onScreenOff();
        }
    
        /**
         * screen状态广播接收者
         */
        private class ScreenBroadcastReceiver extends BroadcastReceiver {
            private String action = null;
    
            @Override
            public void onReceive(Context context, Intent intent) {
                action = intent.getAction();
                if (Intent.ACTION_SCREEN_ON.equals(action)) { // 开屏
                    mListener.onScreenOn();
                } else if (Intent.ACTION_SCREEN_OFF.equals(action)) { // 锁屏
                    mListener.onScreenOff();
                }
            }
        }
    
        public void registerListener(ScreenStateListener listener) {
            mListener = listener;
            registerListener();
        }
    
        private void registerListener() {
            IntentFilter filter = new IntentFilter();
            filter.addAction(Intent.ACTION_SCREEN_ON);
            filter.addAction(Intent.ACTION_SCREEN_OFF);
            mContext.registerReceiver(mScreenReceiver, filter);
        }
    }
    public class ScreenManager {
    
        private Context mContext;
    
        private WeakReference<Activity> mActivityWref;
    
        public static ScreenManager gDefualt;
    
        public static ScreenManager getInstance(Context pContext) {
            if (gDefualt == null) {
                gDefualt = new ScreenManager(pContext.getApplicationContext());
            }
            return gDefualt;
        }
        private ScreenManager(Context pContext) {
            this.mContext = pContext;
        }
    
        public void setActivity(Activity pActivity) {
            mActivityWref = new WeakReference<Activity>(pActivity);
        }
    
        public void startActivity() {
                SinglePixelActivity.actionToSinglePixelActivity(mContext);
        }
    
        public void finishActivity() {
            //结束掉SinglePixelActivity
            if (mActivityWref != null) {
                Activity activity = mActivityWref.get();
                if (activity != null) {
                    activity.finish();
                }
            }
        }
    }

现在MainActivity改成如下

public class MainActivity extends AppCompatActivity {
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            final ScreenManager screenManager = ScreenManager.getInstance(MainActivity.this);
            ScreenBroadcastListener listener = new ScreenBroadcastListener(this);
             listener.registerListener(new ScreenBroadcastListener.ScreenStateListener() {
                @Override
                public void onScreenOn() {
                    screenManager.finishActivity();
                }
    
                @Override
                public void onScreenOff() {
                    screenManager.startActivity();
                }
            });
        }
    }

（2）、启动前台Service  
说这个微信也用过的进程保活方案，该方案实际利用了Android前台service的漏洞。  
原理如下  
对于 API level < 18 ：调用startForeground(ID， new Notification())，发送空的Notification ，图标则不会显示。  
对于 API level >= 18：在需要提优先级的service A启动一个InnerService，两个服务同时startForeground，且绑定同样的 ID。Stop 掉InnerService ，这样通知栏图标即被移除。

public class KeepLiveService extends Service {
    
        public static final int NOTIFICATION_ID=0x11;
    
        public KeepLiveService() {
        }
    
        @Override
        public IBinder onBind(Intent intent) {
            throw new UnsupportedOperationException("Not yet implemented");
        }
    
        @Override
        public void onCreate() {
            super.onCreate();
             //API 18以下，直接发送Notification并将其置为前台
            if (Build.VERSION.SDK_INT <Build.VERSION_CODES.JELLY_BEAN_MR2) {
                startForeground(NOTIFICATION_ID, new Notification());
            } else {
                //API 18以上，发送Notification并将其置为前台后，启动InnerService
                Notification.Builder builder = new Notification.Builder(this);
                builder.setSmallIcon(R.mipmap.ic_launcher);
                startForeground(NOTIFICATION_ID, builder.build());
                startService(new Intent(this, InnerService.class));
            }
        }
    
        public  static class  InnerService extends Service{
            @Override
            public IBinder onBind(Intent intent) {
                return null;
            }
            @Override
            public void onCreate() {
                super.onCreate();
                //发送与KeepLiveService中ID相同的Notification，然后将其取消并取消自己的前台显示
                Notification.Builder builder = new Notification.Builder(this);
                builder.setSmallIcon(R.mipmap.ic_launcher);
                startForeground(NOTIFICATION_ID, builder.build());
                new Handler().postDelayed(new Runnable() {
                    @Override
                    public void run() {
                        stopForeground(true);
                        NotificationManager manager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
                        manager.cancel(NOTIFICATION_ID);
                        stopSelf();
                    }
                },100);
    
            }
        }
    }

（3）、进程相互唤醒  
顾名思义,就是指的不同进程,不同app之间互相唤醒,如你手机里装了支付宝、淘宝、天猫、UC等阿里系的app，那么你打开任意一个阿里系的app后，有可能就顺便把其他阿里系的app给唤醒了。

（4）总结  
多种保活方式,没有说哪一种最好,只有是在什么场景下,使用哪一种最合适;当然,这些方式不是我发明或发现的,但是我觉得如果不知道的好好了解一下,对自己会有很大的帮助.掌握一些进程保活的手段,这不是耍流氓，是很多场景如果要想为用户服务，就必须有一个进程常驻，以便在特定的时候做特定的事情。诚然，但凡进程常驻内存，无论怎样优化，都会或多或少的增加一些额外的性能开支，在为用户最负责任的服务，最高品质的体现我们的价值的前提下，我们要尽可能减少内存和电量的消耗。