Android保活策略

进程的划分

一、前台进程
相关场景:
(1)某个进程持有一个正在与用户交互的Activity并且该Activity正处于resume状态
(2)某个进程持有一个Service,并且该Service调用startForeground()方法使之位于前台运行
(3)某个进程持有一个BroadcastReceiver,并且该BroadcastReceiver正在执行其onReceive()方法

用户正在使用的程序,一般系统是不会杀死前台进程的,除非用户强制停止应用或者系统内存不足等极端情况会杀死

二、可见进程
相关场景:
(1)拥有不在前台、但仍对用户可见的 Activity(已调用 onPause())
(2)拥有绑定到可见Activity 的 Service

用户正在使用,看得到,但是摸不着,没有覆盖到整个屏幕,可见进程不包含任何前台组件,一般系统也是不会杀死可见进程的,除非要在资源吃紧的情况下

三、服务进程
相关场景:某个进程中运行着一个Service且该Service是通过startService()启动的,与用户看见的界面没有直接关联

在内存不足以维持所有前台进程和可见进程同时运行的情况下,服务进程会被杀死

四、后台进程
相关场景:在用户按了"back"或者"home"后,程序本身看不到了,但是其实还在运行的程序,比如Activity调用了onPause方法

系统可能随时终止它们,回收内存

五、空进程

某个进程不包含任何活跃的组件时该进程就会被置为空进程,完全没用,第一个干它

内存阈值

app在退到后台时系统并不会真正的kill掉这个进程,而是将其缓存起来。打开的应用越多,后台缓存的进程也越多。在系统内存不足的情况下,系统开始依据自身的一套进程回收机制来判断要kill掉哪些进程,以腾出内存来供给需要的app,这套进程回收内存的机制就叫 Low Memory Killer。那这个不足怎么来规定呢?那就是内存阈值,内存阈值在不同的手机上不一样,一旦低于该值,Android便开始按顺序关闭进程,Android开始结束优先级最低的空进程,读到这里,你或许有一个疑问,假设现在内存不足,空进程都被杀光了,现在要杀后台进程,但是手机中后台进程很多,难道要一次性全部都清理掉?当然不是的,进程是有它的优先级的,这个优先级通过进程的adj值来反映,它是linux内核分配给每个系统进程的一个值,代表进程的优先级,进程回收机制就是根据这个优先级来决定是否进行回收,adj值定义在com.android.server.am.ProcessList类中

oom_adj越大,占用物理内存越多会被最先kill掉,OK,那么现在对于进程如何保活这个问题就转化成,如何降低oom_adj的值,以及如何使得我们应用占的内存最少

进程保活方案

其实,要做到完全保活是不现实的,谷歌不会让你这么做的。在Android5.0以后,在应用退出后,ActivityManagerService不仅把主进程给杀死,另外把主进程所属的进程组一并杀死,这样一来,由于子进程和主进程在同一进程组,子进程在做的事情,就停止了

一、双进程守护

双进程守护的思想就是,两个进程共同运行,如果有其中一个进程被杀,那么另一个进程就会将被杀的进程重新拉起,相互保护,在一定的意义上,维持进程的不断运行
首先MainActivity页面很简单,就三个按钮,用于启动停止服务,模拟进程被kill

class MainActivity : AppCompatActivity() {
     

    override fun onCreate(savedInstanceState: Bundle?) {
     
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        setListener()
    }

    private fun setListener() {
     
        btn1.setOnClickListener {
     
            startService(Intent(this, LocalService::class.java))
        }
        btn2.setOnClickListener {
     
            stopService(Intent(this, LocalService::class.java))
        }
        btn3.setOnClickListener {
     
            stopService(Intent(this, GuardService::class.java))
        }
    }
}

新建AIDL,用于进程间的交互,注意此处要Rebuild

interface IMyAidlInterface {
     
     String getServiceName();
}

本地进程服务

class LocalService : Service() {
     
    private val connection: ServiceConnection by lazy {
     
        object : ServiceConnection {
     
            override fun onServiceConnected(p0: ComponentName?, p1: IBinder?) {
     
                val aidlInterface = IMyAidlInterface.Stub.asInterface(p1)
                try {
     
                    Log.i("LocalService", "connected with" + aidlInterface.serviceName)
                } catch (e: RemoteException) {
     
                    e.printStackTrace()
                }
            }

            override fun onServiceDisconnected(p0: ComponentName?) {
     
                Toast.makeText(this@LocalService, "守护进程连接断开,重新启动守护", Toast.LENGTH_SHORT).show()
                startService(Intent(this@LocalService, GuardService::class.java))
                bindService(
                    Intent(this@LocalService, GuardService::class.java),
                    connection,
                    Context.BIND_IMPORTANT
                )
            }

        }
    }

    override fun onBind(intent: Intent): IBinder {
     
        return MyBinder()
    }

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
     
        Toast.makeText(this, "本地服务启动", Toast.LENGTH_SHORT).show()
        startService(Intent(this@LocalService, GuardService::class.java))
        bindService(Intent(this, GuardService::class.java), connection, BIND_IMPORTANT)
        return START_STICKY
    }

    class MyBinder : IMyAidlInterface.Stub() {
     
        @Throws(RemoteException::class)
        override fun getServiceName(): String {
     
            return LocalService::class.java.name
        }
    }
}

接下来是守护进程,需要注意的是,守护进程需要跑在另一个进程

        <service
            android:name=".GuardService"
            android:enabled="true"
            android:exported="true"
            android:process=":RemoteProcess"/>

class GuardService : Service() {
     

    private val connection: ServiceConnection by lazy {
     
        object : ServiceConnection {
     
            override fun onServiceConnected(p0: ComponentName?, p1: IBinder?) {
     
                val aidlInterface = IMyAidlInterface.Stub.asInterface(p1)
                try {
     
                    Log.i("LocalService", "connected with" + aidlInterface.serviceName)
                } catch (e: RemoteException) {
     
                    e.printStackTrace()
                }
            }

            override fun onServiceDisconnected(p0: ComponentName?) {
     
                Toast.makeText(this@GuardService, "守护进程连接断开,重新启动本地", Toast.LENGTH_SHORT).show()
                startService(Intent(this@GuardService, LocalService::class.java))
                bindService(
                    Intent(this@GuardService, LocalService::class.java),
                    connection,
                    Context.BIND_IMPORTANT
                )
            }

        }
    }

    override fun onBind(intent: Intent): IBinder {
     
        return MyBinder()
    }

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
     
        Toast.makeText(this, "守护进程服务启动", Toast.LENGTH_SHORT).show()
        bindService(Intent(this, LocalService::class.java), connection, BIND_IMPORTANT)
        return START_STICKY
    }

    class MyBinder : IMyAidlInterface.Stub() {
     
        @Throws(RemoteException::class)
        override fun getServiceName(): String {
     
            return LocalService::class.java.name
        }
    }
}

二、设置前台服务,提升App进程优先级

class ForegroundService : Service() {
     
    companion object {
     
        private const val SERVICE_ID = 1
    }
    
    override fun onCreate() {
     
        super.onCreate()
        Log.d("ForegroundServiceNew", "开启ForegroundService")
    }

    override fun onDestroy() {
     
        super.onDestroy()
        Log.d("ForegroundServiceNew", "销毁ForegroundService")
    }

    override fun onBind(intent: Intent): IBinder? {
     
        return null
    }

    @RequiresApi(api = Build.VERSION_CODES.O)
    override fun onStartCommand(intent: Intent, flags: Int, startId: Int): Int {
     

        //判断版本
        if (Build.VERSION.SDK_INT < 18) {
      //Android4.3以下版本
            //将Service设置为前台服务,可以取消通知栏消息
            startForeground(SERVICE_ID, Notification())
        } else if (Build.VERSION.SDK_INT < 24) {
      //Android4.3 - 7.0之间
            //将Service设置为前台服务,可以取消通知栏消息
            startForeground(SERVICE_ID, Notification())
            startService(Intent(this, InnerService::class.java))
        } else {
      //Android 8.0以上
            val manager = getSystemService(NOTIFICATION_SERVICE) as NotificationManager
            if (manager != null) {
     
                val channel =
                    NotificationChannel("channel", "name", NotificationManager.IMPORTANCE_NONE)
                manager.createNotificationChannel(channel)
                val builder = NotificationCompat.Builder(this, "channel")
                startForeground(SERVICE_ID, Notification())
            }
        }
        return START_STICKY
    }

    class InnerService : Service() {
     
        override fun onBind(intent: Intent): IBinder? {
     
            return null
        }

        override fun onStartCommand(intent: Intent, flags: Int, startId: Int): Int {
     
            startForeground(SERVICE_ID, Notification())
            stopForeground(true) //移除通知栏消息
            stopSelf()
            return super.onStartCommand(intent, flags, startId)
        }
    }
}

最后在Activity中直接启动服务就行

 startService(Intent(this, ForegroundService::class.java))

你可能感兴趣的:(Android保活策略)