android防止被杀
❶ Android如何避免Service被杀掉,如果被杀掉应如何处理。
service 如果你不是bind绑定启动的话,你不执行stop应该不会被轻易的杀死. 但是如果你遇上了像360等等手机助手的话,他们会直接的杀死在后台运行的serice,这个是没法避免的.
至于Service被杀掉 ,你只能打开程序重新启动一下.举个例子就是你在后台放歌,你清理的一下手机,如果没有特殊的设置,放歌的软件和服务都会被清楚,你只能重新打开软件
❷ 怎样使一个Android应用不被杀死
除非你把程序放到 /system/app 目录下,这样安卓就会当它是系统应用了
但是这是需要root权限才可以的
通常情况下,为了防止程序被kill 一般的做法是注册一堆的广播,例如开机,网络,等状态广播
一收到广播就去Intent 一下service,也就是说,即便程序被kill 一会又会重启了
❸ Android防止杀进程
1.在service中重写下面的方法，这个方法有三个返回值， START_STICKY是service被kill掉后自动重写创建 [代码]java代码： @Override public int onStartCommand(Intent intent, int flags, int startId) { return START_STICKY; }---------------- @Override public int onStartCommand(Intent intent, int flags, int startId) { // TODO Auto-generated method stub Log.v("TrafficService","startCommand"); flags = START_STICKY; return super.onStartCommand(intent, flags, startId); // return START_REDELIVER_INTENT; } 2.在Service的onDestroy()中重启Service. public void onDestroy() { Intent localIntent = new Intent(); localIntent.setClass(this, MyService.class); //销毁时重新启动Service this.startService(localIntent); } 用qq管家杀掉进程的时候，调用的是系统自带的强制kill功能（即settings里的），在kill时，会将应用的整个进程停掉，当然包括service在内，如果在running里将service强制kill掉，显示进程还在。不管是kill整个进程还是只kill掉进应用的 service，都不会重新启动service。不知道你是怎么实现重启的，实在是不解。 在eclipse中，用stop按钮kill掉进程的时候，倒是会重启service KILL问题： 1. settings 中stop service onDestroy方法中，调用startService进行Service的重启。 2.settings中force stop 应用 捕捉系统进行广播（action为android.intent.action.PACKAGE_RESTARTED） 3. 借助第三方应用kill掉running task 提升service的优先级 service开机启动 今天我们主要来探讨android怎么让一个service开机自动启动功能的实现。Android手机在启动的过程中会触发一个Standard Broadcast Action，名字叫android.intent.action.BOOT_COMPLETED(记得只会触发一次呀),在这里我们可以通过构建一个广播接收者来接收这个这个action.下面我就来简单写以下实现的步骤： 第一步：首先创建一个广播接收者,重构其抽象方法 onReceive(Context context, Intent intent)，在其中启动你想要启动的Service或app。 [代码]java代码： import android.content.BroadcastReceiver; import android.content.Context; import android.content.Intent; import android.util.Log; public class BootBroadcastReceiver extends BroadcastReceiver { //重写onReceive方法 @Override public void onReceive(Context context, Intent intent) { //后边的XXX.class就是要启动的服务 Intent service = new Intent(context,XXXclass); context.startService(service); Log.v("TAG", "开机自动服务自动启动....."); //启动应用，参数为需要自动启动的应用的包名 Intent intent = getPackageManager().getLaunchIntentForPackage(packageName); context.startActivity(intent ); } } 第二步：配置xml文件，在re ceiver接收这种添加intent-filter配置 [代码]java代码： <receiver android:name="BootBroadcastReceiver"> <intent-filter> <action android:name="android.intent.action.BOOT_COMPLETED"></action> <category android:name="android.intent.category.LAUNCHER" /> </intent-filter> </receiver> 第三步：添加权限 <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" /> 如何实现一个不会被杀死的进程 看Android的文档知道，当进程长期不活动，或系统需要资源时，会自动清理门户，杀死一些Service，和不可见的Activity等所在的进程。 但是如果某个进程不想被杀死（如数据缓存进程，或状态监控进程，或远程服务进程），应该怎么做，才能使进程不被杀死。 add android:persistent="true" into the <application> section in your AndroidManifest.xml 切记，这个 不可滥用，系统中用这个的service，app一多，整个系统就完蛋了。 目前系统中有phone等非常有限的，必须一直活着的应用在试用。 提升service优先级的方法 Android 系统对于内存管理有自己的一套方法，为了保障系统有序稳定的运信，系统内部会自动分配，控制程序的内存使用。当系统觉得当前的资源非常有限的时候，为了保 证一些优先级高的程序能运行，就会杀掉一些他认为不重要的程序或者服务来释放内存。这样就能保证真正对用户有用的程序仍然再运行。如果你的 Service 碰上了这种情况，多半会先被杀掉。但如果你增加 Service 的优先级就能让他多留一会，我们可以用 setForeground(true) 来设置 Service 的优先级。 为什么是 foreground ? 默认启动的 Service 是被标记为 background，当前运行的 Activity 一般被标记为 foreground，也就是说你给 Service 设置了 foreground 那么他就和正在运行的 Activity 类似优先级得到了一定的提高。当让这并不能保证你得 Service 永远不被杀掉，只是提高了他的优先级。 从Android 1.5开始，一个已启动的service可以调用startForeground(int, Notification)将service置为foreground状态，调用stopForeground(boolean)将service置为 background状态。 我们会在调用startForeground(int, Notification)传入参数notification，它会在状态栏里显示正在进行的foreground service。background service不会在状态栏里显示。 在Android 1.0中，将一个service置为foreground状态： setForeground(true); mNM.notify(id, notification); 将一个service置为background状态： mNM.cancel(id); setForeground(false); 对比看出，在1.0 API中调用setForeground(boolean)只是简单的改变service的状态，用户不会有任何觉察。新API中强制将 notification和改变service状态的动作绑定起来，foreground service会在状态栏显示，而background service不会。 Remote service controller & binding 跨进程调用Service。暂时不研究。 如何防止Android应用中的Service被系统回收? 很多朋友都在问，如何防止Android应用中的Service被系统回收？下面简单解答一下。 对于Service被系统回收，一般做法是通过提高优先级可以解决，在AndroidManifest.xml文件中对于intent-filter可以通过 android:priority = "1000"这个属性设置最高优先级，1000是最高值，如果数字越小则优先级越低，同时实用于广播，推荐大家如果你的应用很重要，可以考虑通过系统常用intent action来触发。
❹ android 怎么保证服务不被杀死
1: 正常 stop service的时候会执行生命周期的 onDestory() 可以在销毁方法中执行再次 startService();
2: 当收到内存影响的时候，out-of-memory killer会销毁掉一些优先级低的app：
相较于/data/app下的应用，放在/system/app下的应用享受更多的特权，
比如若在其Manifest.xml文件中设置persistent属性为true，
则可使其免受out-of-memory killer的影响。
如应用程序'Phone'的AndroidManifest.xml文件：
<application android:name="PhoneApp"
android:persistent="true"
android:label="@string/dialerIconLabel"
android:icon="@drawable/ic_launcher_phone">
...
</application>
设置后app提升为系统核心级别，任何情况下不会被kill掉,
settings->applications里面也会屏蔽掉stop操作,再次情况下，发现4.1.2的程序在设置里面的应用里面，程序没有禁止掉停止。
在此情况下还要应用上1的重新启动。
3: force stop service 的时候，则不执行 onDestory(),
还有一种情况是 第三方任务管理器清理掉整个程序的时候；
google 管方就有，ForegroundService 前台服务，让服务一直以前台任务的方式运行，可以在service 的oncreate来实现前台服务， 通过这个方法必须发送一个通知栏，让用户知道服务在运行。我们可以把service修改成前台运行方式，只不过让通知notification不去显示就OK了。
❺ 想让android应用常驻后台，不被杀死，各位大神有什么高招
方法： 对于一个service，可以首先把它设为在前台运行： public void MyService.onCreate() { super.onCreate(); Notification notification = new Notification(android.R.drawable.my_service_icon, "my_service_name", System.currentTimeMillis()); PendingIntent p_intent = PendingIntent.getActivity(this, 0, new Intent(this, MyMainActivity.class), 0); notification.setLatestEventInfo(this, "MyServiceNotification, "MyServiceNotification is Running!", p_intent); Log.d(TAG, String.format("notification = %s", notification)); startForeground(0x1982, notification); // notification ID: 0x1982, you can name it as you will. } 重要设置------------------------------- 相较于/data/app下的应用，放在/system/app下的应用享受更多的特权，比如若在其Manifest.xml文件中设置persistent属性为true，则可使其免受out-of-memory killer的影响。如应用程序'Phone'的AndroidManifest.xml文件： <application android:name="PhoneApp" android:persistent="true" android:label="@string/dialerIconLabel" android:icon="@drawable/ic_launcher_phone"> ... </application> 设置后app提升为系统核心级别，任何情况下不会被kill掉, settings->applications里面也会屏蔽掉stop操作。 这样设置前的log: Proc #19: adj=svc /B 4067b028 255:com.xxx.xxx/10001 (started-services) # cat /proc/255/oom_adj 设置后的log: PERS #19: adj=core /F 406291f0 155:com.xxx.xxx/10001 (fixed) # cat /proc/155/oom_adj -12 # 这是CORE_SERVER_ADJ 注：init进程的oom_adj为-16（即SYSTEM_ADJ）： cat /proc/1/oom_adj Android相关部分分析： 在文件frameworks/base/services/java/com/android/server/am/ActivityManagerService.java中有以下的代码： final ProcessRecord addAppLocked(ApplicationInfo info) { ProcessRecord app = getProcessRecordLocked(info.processName, info.uid); if (app == null) { app = newProcessRecordLocked(null, info, null); mProcessNames.put(info.processName, info.uid, app); updateLruProcessLocked(app, true, true); } if ((info.flags&(ApplicationInfo.FLAG_SYSTEMApplicationInfo.FLAG_PERSISTENT)) == (ApplicationInfo.FLAG_SYSTEMApplicationInfo.FLAG_PERSISTENT)) { app.persistent = true; app.maxAdj = CORE_SERVER_ADJ; // 这个常数值为-12。 } if (app.thread == null && mPersistentStartingProcesses.indexOf(app) < 0) { mPersistentStartingProcesses.add(app); startProcessLocked(app, "added application", app.processName); } return app; } 可见要想成为core service （即app.maxAdj = CORE_SERVER_ADJ(-12)），应用程序需要FLAG_SYSTEM和FLAG_PERSISTENT两个标志，FLAG_SYSTEM指的是应用位于/system/app下，FLAG_PERSISTENT就是指persistent属性。 而对于frameworks/base/services/java/com/android/server/SystemServer.java，则调用 ActivityManagerService.setSystemProcess(); 把自己的 app.maxAdj 设置成SYSTEM_ADJ，即-16。 原理： Android中的进程是托管的，当系统进程空间紧张的时候，会依照优先级自动进行进程的回收。由此带来三个问题： 1） 回收规则: 什么时候回收与回收哪一个？ 2） 避免误杀: 如何阻止被回收？ 3） 数据恢复与保存: 被回收了怎么办？ Android将进程分为6个等级,它们按优先级顺序由高到低依次是: 1.前台进程( FOREGROUND_APP) 2.可视进程(VISIBLE_APP ) 3. 次要服务进程(SECONDARY_SERVER ) 4.后台进程 (HIDDEN_APP) 5.内容供应节点(CONTENT_PROVIDER) 6.空进程(EMPTY_APP) 特征： 1.如果一个进程里面同时包含service和可视的activity，那么这个进程应该归于可视进程，而不是service进程。 2.另外，如果其他进程依赖于它的话，一个进程的等级可以提高。例如，一个A进程里的service被绑定到B进程里的组件上，进程A将总被认为至少和B进程一样重要。 3.系统中的phone服务被划分到前台进程而不是次要服务进程. 在android中，进程的oom_adj值也就代表了它的优先级。oom_adj值越高代表该进程优先级越低。文件/init.rc中有以下属性设置： setprop ro.FOREGROUND_APP_ADJ 0 setprop ro.VISIBLE_APP_ADJ 1 setprop ro.SECONDARY_SERVER_ADJ 2 setprop ro.HIDDEN_APP_MIN_ADJ 7 setprop ro.CONTENT_PROVIDER_ADJ 14 setprop ro.EMPTY_APP_ADJ 15 /init.rc中，将PID为1的进程(init进程)的oom_adj设置为SYSTEM_ADJ(-16): # Set init its forked children's oom_adj. write /proc/1/oom_adj -16 查看本机设置： cat /sys/mole/lowmemorykiller/parameters/adj 0,1,2,7,14,15 回收时机： 文件/init.rc中: setprop ro.FOREGROUND_APP_MEM 1536 // 6M setprop ro.VISIBLE_APP_MEM 2048 // 8M setprop ro.SECONDARY_SERVER_MEM 4096 // 16M setprop ro.HIDDEN_APP_MEM 5120 // 20M setprop ro.CONTENT_PROVIDER_MEM 5632 // 22.4M setprop ro.EMPTY_APP_MEM 6144 // 24M 这些数字也就是对应的内存阈值，一旦低于该值，Android便开始按顺序关闭相应等级的进程。 注意这些数字的单位是page： 1 page = 4 kB。所以上面的六个数字对应的就是(MB): 6,8,16,20,22,24。 查看现在的内存阈值设置： cat /sys/mole/lowmemorykiller/parameters/minfree 要想重新设置该值（对应不同的需求）: echo "1536,2048,4096,5120,15360,23040">/sys/mole/lowmemorykiller/parameters/minfree 这样当可用内存低于90MB的时候便开始杀死"空进程"，而当可用内存低于60MB的时候才开始杀死"内容供应节点"类进程。 具体的回收实现在ActivityManagerService.java中的函数trimApplications()： 1.首先移除package已被卸载的无用进程； 2.基于进程当前状态，更新oom_adj值，然后进行以下操作： 1) 移除没有activity在运行的进程; 2) 如果AP已经保存了所有的activity状态，结束这个AP。 3. 最后，如果目前还是有很多activities 在运行，那么移除那些activity状态已经保存好的activity。 更新oom_adj的值： 在ActivityManagerService.java文件的ComputeOomAdjLocked() 中计算出进程的oom_adj，例如: if (app == TOP_APP) { // The last app on the list is the foreground app. adj = FOREGROUND_APP_ADJ; app.adjType = "top-activity"; } Android kernel中的low memory killer Android的Low Memory Killer根据需要（当系统内存短缺时）杀死进程释放其内存，源代码在kernel/drivers/misc/lowmemorykiller.c中。简单说，就是寻找一个最合适的进程杀死，从而释放它占用的内存。 最合适的进程是: • oom_adj越大 • 占用物理内存越多 一旦一个进程被选中，内核会发送SIGKILL信号将之杀死： for_each_process(p) { …… if(selected == NULL p->oomkilladj > selected->oomkilladj (p->oomkilladj == selected->oomkilladj && tasksize > selected_tasksize)) { selected = p; } } if(selected != NULL) { force_sig(SIGKILL, selected); } 查看LRU列表：adb shell mpsys activity 当activitydemo在前台时： 包含Service的进程的优先级比较高，在computeOomAdjLocked中将其分为了两小类: static final int MAX_SERVICE_INACTIVITY = 30*60*1000; if (now < (s.lastActivity+MAX_SERVICE_INACTIVITY)) { if (adj > SECONDARY_SERVER_ADJ) { adj = SECONDARY_SERVER_ADJ; app.adjType = "started-services"; app.hidden = false; } } if (adj > SECONDARY_SERVER_ADJ) { app.adjType = "started-bg-services"; } 完全让进程不被kill是不可能的，我们可以通过一些操作，使进程被kill的几率变小： 1) 提高进程的优先级: * 后台操作采用运行于前台的Service形式，因为一个运行着service的进程比一个运行着后台activity的等级高； * 按back键使得进程中的activity在后台运行而不是destory，需重载back按键(没有任何activity在运行的进程优先被杀). * 依赖于其他优先级高的进程； 2) 强制修改进程属性： * 在进程中设置：setPersistent(true); * 在Manifest文件中设置（如上）。
❻ 请问android APP 如何防止被系统杀死和用户卸载
这个有点流氓软件的味道了……
如果是防止被杀，参照一下这里吧（Android开发之如何保证Service不被杀掉）
如果要防止用户卸载，可以用辅助功能监听用户是否点开了软件卸载页面，如果点开了，查找页面文字或ID，检测一下是不是你的软件，如果是就点取消。但是需要引导用户把辅助功能打开。
建议不要这么做，防止被杀可以，但是防止卸载如果被举报会招到官司的。
❼ android开发怎么让个推服务不被手机系统杀掉
服务是一个应用程序组件,可以在后台执行长时间运行的操作,不提供用户界面。一个应用程序组件可以启动一个服务,它将继续在后台运行,即使用户切换到另一个应用程序。此外,一个组件可以绑定到一个服务与它交互,甚至执行进程间通信(IPC)。例如,一个服务可能处理网络通信,播放音乐,执行文件I/O,或与一个内容提供者交互,都在后台执行。
一个服务本质上讲有两种形式：
Started 启动的
started 形式的服务是指当一个应用组件(比如 activity )通过startService()方法开启的服务。一旦开启，该服务就可以 无限期 地在后台运行，哪怕开启它的组件被销毁掉。
通常,开启的服务执行一个单独的操作且并不向调用者返回一个结果。
比如，可能从网络进行下载或者上传一个文件。当任务完成，服务就该自我停止。
Bound 绑定的
bound 形式的服务是指一个应用组件通过调用 bindService() 方法与服务绑定。一个绑定的服务提供一个客户-服务端接口，以允许组件与服务交互，发送请求，获得结果，甚至执行进程间通信。一个绑定的服务只和与其绑定的组件同时运行。多个组件可以同时绑定到一个服务，但当全部接触绑定后，服务就被销毁。
虽然分这两类，但是一个服务可以同时使用这两种方式——可以用 started 无限期的运行，同时允许绑定。只需要在服务中实现两个回调方法： onStartCommand() 允许组件开启服务， onBind() 允许绑定。
不论应用程序是怎么起服务的， 任何 应用程序都可以用这个服务。同样的，任何组件可以使用一个 Activity 通过传递 Intent 开启服务。你也可以在配置文件设置服务为私有来防止其他应用访问该服务。
注意： 一个服务在进程中的主线程运行——一个服务 不会 创建自己的线程，也 不会 在另外的进程运行(除非另外指定)。这意味着，如果服务需要做一些频繁占用CPU的工作或者会发生阻塞的操作，你需要在服务中另开线程执行任务。这可以降低产生ANR的风险，提高用户体验。
基础
创建一个服务需要建立一个 Service 相关的子类，然后需要实现一些回调方法，好在不同的生命周期内做对应处理和绑定服务，比较重要的方法如下：
onStartCommand()
当其他组件，如 activity 请求服务启动时，系统会调用这个方法。一旦这个方法执行，服务就开始并且无限期的执行。如果实现这个方法，当这个服务完成任务后，需要你来调用 stopSelf() 或者 stopService() 停掉服务。如果只想提供绑定，不需要自己实现这个方法。
onBind()
当有其他组件想通过 bindService() 方法绑定这个服务时系统就会调用此方法。在实现的方法里面，必须添加一个供客户端使用的接口通过返回一个 IBinder 来与服务通信，这个方法必须实现。当然不想允许绑定的话，返回 null 即可。
onCreate()
服务第一次建立的时候会调用这个方法，执行一次性设置程序，在上面2个方法执行前调用。如果服务已存在，则不执行该方法。
onDestroy()
服务不再使用则使用该方法。服务应该实现这个方法来清理诸如线程，注册的监听器等资源。这是最后调用的方法。
安卓系统只会在内存占用很高，必须恢复系统资源供当前运行程序的情况下强制停掉一个运行中的服务。如果服务绑定在当前运行的程序中，就几乎不会被杀掉，如果服务声明了在前台运行（其实在后台，只是给系统一个错的信息来提高优先级），就几乎不会被杀掉。另外，如果一个服务正在运行，且运行了很久，系统就会根据运行时间把其排在后台任务列表的后面，则这个服务很容易被杀掉。根据onStartCommand() 的返回值设置，服务被杀掉后仍可以在资源充足的条件下立即重启。
是用一个服务好还是开一个线程好
一个服务就是一个可以忽略交互，在后台独立运行的组件，如果你需要这样就用服务
如果你需要在用户与程序交互时在主线程外执行任务，那就开个线程吧。
比如想播放音乐，但只在程序运行时播放，你可能在 onCreate() 开一个线程，在 onStart() 中开启它，在 onStop() 停止它。也可以考虑使用 AsyncTask 或者HandlerThread 取代一般的线程。
记住，如果使用一个服务，它还是默认在主线程中运行，如果会发生阻塞，还是要在服务中另开线程的。
在 manifest 文件声明服务
要使用服务就必须在 manifest 文件声明要用的所有服务，只用在<application> 标签内添加子标签 <service> 即可。
<manifest ...>
...
<application ...>
<service android:name=".ExampleService"
android:enabled=["true" | "false"]
android:exported=["true" | "false"]
android:isolatedProcess=["true" | "false"]
android:label="string resource"
android:icon="drawable resource"
android:permission="string"
android:process="string" >
...
</service>
</application>
</manifest>
下面对 service 标签属性做说明
android:name
你所编写的服务类的类名，可填写完整名称，包名+类名，如com.example.test.ServiceA ，也可以忽略包名，用 . 开头，如 .ServiceA，因为在 manifest 文件开头会定义包名，它会自己引用。
一旦你发布应用，你就不能改这个名字(除非设置 android:exported="false")，另外 name 没有默认值，必须定义。
android:enabled
是否可以被系统实例化，默认为 true
因为父标签 <application> 也有 enable 属性，所以必须两个都为默认值true 的情况下服务才会被激活，否则不会激活。
android:exported
其他应用能否访问该服务，如果不能，则只有本应用或有相同用户ID的应用能访问。当然除了该属性也可以在下面 permission 中限制其他应用访问本服务。
这个默认值与服务是否包含意图过滤器 intent filters 有关。如果一个也没有则为 false
android:isolatedProcess
设置 true 意味着，服务会在一个特殊的进程下运行，这个进程与系统其他进程分开且没有自己的权限。与其通信的唯一途径是通过服务的API(binding and starting)。
android:label
可以显示给用户的服务名称。如果没设置，就用 <application> 的 lable 。不管怎样，这个值是所有服务的意图过滤器的默认 lable 。定义尽量用对字符串资源的引用。
android:icon
类似 label ，是图标，尽量用 drawable 资源的引用定义。
android:permission
是一个实体必须要运行或绑定一个服务的权限。如果没有权限，startService() ， bindService() 或 stopService() 方法将不执行，Intent 也不会传递到服务。
如果属性未设置，会由 <application> 权限设置情况应用到服务。如果两者都未设置，服务就不受权限保护。
android:process
服务运行所在的进程名。通常为默认为应用程序所在的进程，与包名同名。<application> 元素的属性 process 可以设置不同的进程名，当然组件也可设置自己的进程覆盖应用的设置。
如果名称设置为冒号 ： 开头，一个对应用程序私有的新进程会在需要时和运行到这个进程时建立。如果名称为小写字母开头，服务会在一个相同名字的全局进程运行，如果有权限这样的话。这允许不同应用程序的组件可以分享一个进程，减少了资源的使用。
创建“启动的”服务
启动的(started)服务由 startService(Intent) 方法启动，在服务中的onStartCommand() 方法里获得 Intent 信息。关闭则由服务自己的方法 stopSelf() 或者由启动服务的地方调用 stopService(Intent) 方法来关闭。并不会因为启动服务的应用程序销毁而关闭。
示例，一个应用需要保存数据到远程数据库，这时启动一个服务，通过创建启动的服务给服务传递数据，由服务执行保存行为，行为结束再自我销毁。因为服务跟启动它的应用在一个进程的主线程中，所以对于耗时的操作要起一个新的线程去做。
//activity中
Intent intent = new Intent(MainActivity.this, ServiceA.class);
intent.putExtra("name", strName);
startService(intent);
//service中
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
// TODO Auto-generated method stub
// 获取数据
String strName = intent.getStringExtra("name");
// ... 数据库操作
new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
耗时的操作
}
}).run();
return Service.START_STICKY;
}
写服务有2种，继承 service 或者 IntentService 。后者是前者的子类。前者包含上面介绍的各种方法，用于普通的服务。后者可以自己开一个工作线程一个接一个处理多个请求。
继承IntentService
大多数服务不需要同时处理多个请求，继承 IntentService 是最好的选择
IntentService处理流程
创建默认的一个 worker 线程处理传递给 onStartCommand() 的所有 intent ，不占据应用的主线程
创建一个工作队列一次传递一个 intent 到你实现的 onHandleIntent() 方法，避免了多线程
在所以启动请求被处理后自动关闭服务，不需要调用 stopSelf()
默认提供 onBind() 的实现，并返回 null
默认提供 onStartCommand() 的实现，实现发送 intent 到工作队列再到你的onHandleIntent() 方法实现。
这些都加入到 IntentService 中了，你需要做的就是实现构造方法和onHandleIntent() ，如下：
public class HelloIntentService extends IntentService {
/**
* A constructor is required, and must call the super IntentService(String)
* constructor with a name for the worker thread.
*/
public HelloIntentService() {
super("HelloIntentService");
}
/**
* The IntentService calls this method from the default worker thread with
* the intent that started the service. When this method returns, IntentService
* stops the service, as appropriate.
*/
@Override
protected void onHandleIntent(Intent intent) {
// Normally we would do some work here, like download a file.
// For our sample, we just sleep for 5 seconds.
long endTime = System.currentTimeMillis() + 5*1000;
while (System.currentTimeMillis() < endTime) {
synchronized (this) {
try {
wait(endTime - System.currentTimeMillis());
} catch (Exception e) {
}
}
}
}
}
如果需要重写其他回调方法，如 onCreate() , onStartCommand() 等，一定要调用super() 方法，保证 IntentService 正确处理 worker 线程，只有 onHandleIntent()和 onBind() 不需要这样。如：
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
Toast.makeText(this, "service starting", Toast.LENGTH_SHORT).show();
return super.onStartCommand(intent,flags,startId);
}
继承Service
继承 Service 就可以实现对请求多线程的处理，前面介绍了 service 的生命周期，可以按照生命周期实现方法。就不放示例了。
onStartCommand() 的返回值
返回一个整型值，用来描述系统在杀掉服务后是否要继续启动服务，返回值有三种：
START_NOT_STICKY
系统不重新创建服务，除非有将要传递来的 intent 。这是最安全的选项，可以避免在不必要的时候运行服务。
START_STICKY
系统重新创建服务并且调用 onStartCommand() 方法，但并不会传递最后一次传递的 intent ，只是传递一个空的 intent 。除非存在将要传递来的 intent ，那么就会传递这些 intent 。这个适合播放器一类的服务，不需要执行命令，只需要独自运行，等待任务。
START_REDELIVER_INTENT
系统重新创建服务并且调用 onStartCommand() 方法，传递最后一次传递的intent 。其余存在的需要传递的intent会按顺序传递进来。这适合像下载一样的服务，立即恢复，积极执行。
如果想从服务获得结果，可以用广播来处理
创建“绑定的”服务
用 bindService() 方法将应用组件绑定到服务，建立一个长时间保持的联系。
如果需要在 activity 或其他组件和服务交互或者通过进程间通信给其他应用程序提供本应用的功能，就需要绑定的服务。
建立一个绑定的服务需要实现 onBind() 方法返回一个定义了与服务通信接口的IBinder 对象。其他应用程序组件可以调用 bindService() 方法获取接口并且调用服务上的方法。
创建一个绑定的服务，第一件事就是定义一个说明客户端与服务通信方式的接口。这个接口必须是 IBinder 的实现，并且必须要从 onBind() 方法返回。一旦客户端接收到了 IBinder ，就可以通过这个接口进行交互。
多个客户端可以绑定到一个服务，可以用 unbindService() 方法解除绑定，当没有组件绑定在服务上，这个服务就会被销毁。
//activity中
private ServiceConnection connB = new ServiceConnection() {
@Override
public void onServiceDisconnected(ComponentName name) {
// TODO Auto-generated method stub
Log.v(tag, "Service B disconnected");
}
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
// TODO Auto-generated method stub
Log.v(tag, "Service B connected");
MyBinderB binder = (MyBinderB) service;
ServiceB SB = binder.getService();
SB.showLog();
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
findViewById(R.id.button1).setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
Intent a = new Intent(MainActivity.this, ServiceB.class);
bindService(a, connB, BIND_AUTO_CREATE);
}
}
//ServiceB
public class ServiceB extends Service {
public void showLog() {
Log.i(tag, "serviceB-->showLog()");
}
public class MyBinderB extends Binder {
public ServiceB getService() {
return ServiceB.this;
}
}
private MyBinderB myBinderB = new MyBinderB();
@Override
public IBinder onBind(Intent intent) {
// TODO Auto-generated method stub
return myBinderB;
}
}
启动前台服务
前台服务是被认为是用户已知的正在运行的服务，当系统需要释放内存时不会优先杀掉该进程。前台进程必须发一个 notification 在状态栏中显示，直到进程被杀死。因为前台服务会一直消耗一部分资源，但不像一般服务那样会在需要的时候被杀掉，所以为了能节约资源，保护电池寿命，一定要在建前台服务的时候发notification ，提示用户。当然，系统提供的方法就是必须有 notification 参数的，所以不要想着怎么把 notification 隐藏掉。
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
// TODO Auto-generated method stub
Intent notificationIntent = new Intent(this, MainActivity.class);
PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, notificationIntent, 0);
Notification noti = new Notification.Builder(this)
.setContentTitle("Title")
.setContentText("Message")
.setSmallIcon(R.drawable.ic_launcher)
.setContentIntent(pendingIntent)
.build();
startForeground(12346, noti);
return Service.START_STICKY;
}
startForeground() 方法就是将服务设为前台服务。参数12346就是这个通知唯一的id，只要不为0即可。
❽ android后台服务保持，不被杀死
作者：闭关写代码
链接：https://www.hu.com/question/29826231/answer/71207109
来源：知乎
着作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
强烈建议不要这么做，不仅仅从用户角度考虑，作为Android开发者也有责任去维护Android的生态环境。现在很多Android开发工程师，主力机居然是iPhone而不是Android设备，感到相当悲哀。
从技术角度概括一下现在普遍的防杀方法
Service设置成START_STICKY，kill 后会被重启（等待5秒左右），重传Intent，保持与重启前一样
通过 startForeground将进程设置为前台进程，做前台服务，优先级和前台应用一个级别，除非在系统内存非常缺，否则此进程不会被 kill
双进程Service：让2个进程互相保护，其中一个Service被清理后，另外没被清理的进程可以立即重启进程
QQ黑科技:在应用退到后台后，另起一个只有 1 像素的页面停留在桌面上，让自己保持前台状态，保护自己不被后台清理工具杀死
在已经root的设备下，修改相应的权限文件，将App伪装成系统级的应用（Android4.0系列的一个漏洞，已经确认可行）
Android系统中当前进程(Process)fork出来的子进程，被系统认为是两个不同的进程。当父进程被杀死的时候，子进程仍然可以存活，并不受影响。鉴于目前提到的在Android-Service层做双守护都会失败，我们可以fork出c进程，多进程守护。死循环在那检查是否还存在，具体的思路如下（Android5.0以下可行）
用C编写守护进程(即子进程)，守护进程做的事情就是循环检查目标进程是否存在，不存在则启动它。
在NDK环境中将1中编写的C代码编译打包成可执行文件(BUILD_EXECUTABLE)。
主进程启动时将守护进程放入私有目录下，赋予可执行权限，启动它即可。
联系厂商，加入白名单
------------------------------------------------------
TIP: 面对各种流氓软件后台常驻问题，建议使用“绿色守护”来解决，可是杀掉那些第三方清理工具难以清除的后台程序
❾ 如何让android app不被后台很快杀死
这个可不好说了，具体关闭程序是由Framework决定的。 一般按照如下规律。 1、内存紧张、先关闭没有SERVICE、ACTIVITY堆栈时间最长的。 2、内存紧张、有SERVICE，不活动时间最长的。占用内存比较大的。 3、内存紧张、有大内存程序切换到前台，释放内存依旧不够的。依次杀死不活动时间最长的。 4、内存紧张、有大内存程序切换到前台，释放内存依旧不够的。杀死带有android:persistent="true"标记的。（备注Phone模块有此标记，所以最难杀） 这个是我的经验。
❿ 如何防止android app被kill
相较于/data/app下的应用，放在/system/app下的应用享受更多的特权，比如若在其Manifest.xml文件中设置persistent属性为true，则可使其免受out-of-memory
killer的影响。如应用程序'Phone'的AndroidManifest.xml文件：
<application
android:name="PhoneApp"
android:persistent="true"
android:label="@string/dialerIconLabel"
android:icon="@drawable/ic_launcher_phone">
...
</application>
设置后app提升为系统核心级别，任何情况下不会被kill掉, settings->applications里面也会屏蔽掉stop操作。
这样设置前的log: Proc #19: adj=svc /B 4067b028 255:com.xxx.xxx/10001 (started-services)
# cat /proc/255/oom_adj
4
设置后的log: PERS #19: adj=core /F 406291f0 155:com.xxx.xxx/10001 (fixed)
# cat /proc/155/oom_adj
-12 # 这是CORE_SERVER_ADJ
注：init进程的oom_adj为-16（即SYSTEM_ADJ）： cat /proc/1/oom_adj
Android相关部分分析：
在文件frameworks/base/services/java/com/android/server/am/ActivityManagerService.java中有以下的代码：
final
ProcessRecord addAppLocked(ApplicationInfo info) {
ProcessRecord
app = getProcessRecordLocked(info.processName, info.uid);
if
(app == null) {
app
= newProcessRecordLocked(null, info, null);
mProcessNames.put(info.processName,
info.uid, app);
updateLruProcessLocked(app,
true, true);
}
if
((info.flags&(ApplicationInfo.FLAG_SYSTEM|ApplicationInfo.FLAG_PERSISTENT))
==
(ApplicationInfo.FLAG_SYSTEM|ApplicationInfo.FLAG_PERSISTENT)) {
app.persistent
= true;
app.maxAdj
= CORE_SERVER_ADJ; //
这个常数值为-12。
}
if
(app.thread == null && mPersistentStartingProcesses.indexOf(app)
< 0) {
mPersistentStartingProcesses.add(app);
startProcessLocked(app,
"added application", app.processName);
}
return
app;
}
可
见要想成为core service （即app.maxAdj =
CORE_SERVER_ADJ(-12)），应用程序需要FLAG_SYSTEM和FLAG_PERSISTENT两个标志，FLAG_SYSTEM指
的是应用位于/system/app下，FLAG_PERSISTENT就是指persistent属性。
而对于frameworks/base/services/java/com/android/server/SystemServer.java，则调用
ActivityManagerService.setSystemProcess();
把自己的 app.maxAdj 设置成SYSTEM_ADJ，即-16。
原理：
Android中的进程是托管的，当系统进程空间紧张的时候，会依照优先级自动进行进程的回收。由此带来三个问题：
1）
回收规则: 什么时候回收与回收哪一个？
2）
避免误杀: 如何阻止被回收？
3）
数据恢复与保存: 被回收了怎么办？
Android将进程分为6个等级,它们按优先级顺序由高到低依次是:
1.前台进程(
FOREGROUND_APP)
2.可视进程(VISIBLE_APP
)
3.
次要服务进程(SECONDARY_SERVER )
4.后台进程
(HIDDEN_APP)
5.内容供应节点(CONTENT_PROVIDER)
6.空进程(EMPTY_APP)
特征：
1.如果一个进程里面同时包含service和可视的activity，那么这个进程应该归于可视进程，而不是service进程。
2.另外，如果其他进程依赖于它的话，一个进程的等级可以提高。例如，一个A进程里的service被绑定到B进程里的组件上，进程A将总被认为至少和B进程一样重要。
3.系统中的phone服务被划分到前台进程而不是次要服务进程.
在android中，进程的oom_adj值也就代表了它的优先级。oom_adj值越高代表该进程优先级越低。文件/init.rc中有以下属性设置：
setprop
ro.FOREGROUND_APP_ADJ 0
setprop
ro.VISIBLE_APP_ADJ 1
setprop
ro.SECONDARY_SERVER_ADJ 2
setprop
ro.HIDDEN_APP_MIN_ADJ 7
setprop
ro.CONTENT_PROVIDER_ADJ 14
setprop
ro.EMPTY_APP_ADJ 15
/init.rc中，将PID为1的进程(init进程)的oom_adj设置为SYSTEM_ADJ(-16):
#
Set init its forked children's oom_adj.
write
/proc/1/oom_adj -16
查看本机设置：
cat /sys/mole/lowmemorykiller/parameters/adj
0,1,2,7,14,15
回收时机：
文件/init.rc中:
setprop
ro.FOREGROUND_APP_MEM 1536 // 6M
setprop
ro.VISIBLE_APP_MEM 2048 // 8M
setprop
ro.SECONDARY_SERVER_MEM 4096 // 16M
setprop
ro.HIDDEN_APP_MEM 5120 // 20M
setprop
ro.CONTENT_PROVIDER_MEM 5632 // 22.4M
setprop
ro.EMPTY_APP_MEM 6144 // 24M
这些数字也就是对应的内存阈值，一旦低于该值，Android便开始按顺序关闭相应等级的进程。
注意这些数字的单位是page： 1 page = 4 kB。所以上面的六个数字对应的就是(MB): 6,8,16,20,22,24。
查看现在的内存阈值设置：
cat /sys/mole/lowmemorykiller/parameters/minfree
要想重新设置该值（对应不同的需求）:
echo "1536,2048,4096,5120,15360,23040">/sys/mole/lowmemorykiller/parameters/minfree
这样当可用内存低于90MB的时候便开始杀死"空进程"，而当可用内存低于60MB的时候才开始杀死"内容供应节点"类进程。
具体的回收实现在ActivityManagerService.java中的函数trimApplications()：
1.首先移除package已被卸载的无用进程；
2.基于进程当前状态，更新oom_adj值，然后进行以下操作：
1)
移除没有activity在运行的进程;
2)
如果AP已经保存了所有的activity状态，结束这个AP。
3.
最后，如果目前还是有很多activities 在运行，那么移除那些activity状态已经保存好的activity。
更新oom_adj的值：
在ActivityManagerService.java文件的ComputeOomAdjLocked() 中计算出进程的oom_adj，例如:
if
(app == TOP_APP) {
//
The last app on the list is the foreground app.
adj
= FOREGROUND_APP_ADJ;
app.adjType
= "top-activity";
}
Android kernel中的low memory killer
Android的Low Memory Killer根据需要（当系统内存短缺时）杀死进程释放其内存，源代码在kernel/drivers/misc/lowmemorykiller.c中。简单说，就是寻找一个最合适的进程杀死，从而释放它占用的内存。
最合适的进程是:
• oom_adj越大
• 占用物理内存越多
一旦一个进程被选中，内核会发送SIGKILL信号将之杀死：
for_each_process(p)
{
……
if(selected
== NULL || p->oomkilladj
> selected->oomkilladj ||
(p->oomkilladj
== selected->oomkilladj && tasksize > selected_tasksize))
{
selected
= p;
}
}
if(selected
!= NULL) {
force_sig(SIGKILL,
selected);
}
查看LRU列表：adb shell mpsys activity
当activitydemo在前台时：
包含Service的进程的优先级比较高，在computeOomAdjLocked中将其分为了两小类:
static
final int MAX_SERVICE_INACTIVITY = 30*60*1000;
if
(now < (s.lastActivity+MAX_SERVICE_INACTIVITY)) {
if
(adj > SECONDARY_SERVER_ADJ) {
adj
= SECONDARY_SERVER_ADJ;
app.adjType
= "started-services";
app.hidden
= false;
}
}
if
(adj > SECONDARY_SERVER_ADJ) {
app.adjType
= "started-bg-services";
}
完全让进程不被kill是不可能的，我们可以通过一些操作，使进程被kill的几率变小：
1)
提高进程的优先级:
*
后台操作采用运行于前台的Service形式，因为一个运行着service的进程比一个运行着后台activity的等级高；
*
按back键使得进程中的activity在后台运行而不是destory，需重载back按键(没有任何activity在运行的进程优先被杀).
*
依赖于其他优先级高的进程；
2)
强制修改进程属性：
*
在进程中设置：setPersistent(true);
*
在Manifest文件中设置（如上）。