android进程service
❶ android如何判断后台一个Service是否在运行
当你了解Service的生命周期以后,你就会明白,你可以在onStop 或者onDestroy()中记录一下状态,onStop 执行以后,那么service肯定是停止的，Service是在一段不定的时间运行在后台，不和用户交互应用组件。每个Service必须在manifest中 通过<service>来声明。可以通过contect.startservice和contect.bindserverice来启动。
Service生命周期
使用context.startService() 启动Service是会会经历:
context.startService() ->onCreate()- >onStart()->Service running
context.stopService() | ->onDestroy() ->Service stop
在Service每一次的开启关闭过程中，只有onStart可被多次调用(通过多次startService调用)，其他onCreate，onBind，onUnbind，onDestory在一个生命周期中只能被调用一次。
而启动service，根据onStartCommand的返回值不同，有两个附加的模式：
1. START_STICKY 用于显示启动和停止service。
2. START_NOT_STICKY或START_REDELIVER_INTENT用于有命令需要处理时才运行的模式。
Service不能自己运行，需要通过调用Context.startService()或Context.bindService()方法启动服务。这两个方法都可以启动Service，但是它们的使用场合有所不同。
使用startService()方法启用服务，调用者与服务之间没有关连，即使调用者退出了，服务仍然运行。如果打算采用Context.startService()方法启动服务，在服务未被创建时，系统会先调用服务的onCreate()方法，接着调用onStart()方法。如果调用startService()方法前服务已经被创建，多次调用startService()方法并不会导致多次创建服务，但会导致多次调用onStart()方法。采用startService()方法启动的服务，只能调用Context.stopService()方法结束服务，服务结束时会调用onDestroy()方法。
使用bindService()方法启用服务，调用者与服务绑定在了一起，调用者一旦退出，服务也就终止，大有“不求同时生，必须同时死”的特点。onBind()只有采用Context.bindService()方法启动服务时才会回调该方法。该方法在调用者与服务绑定时被调用，当调用者与服务已经绑定，多次调用Context.bindService()方法并不会导致该方法被多次调用。采用Context.bindService()方法启动服务时只能调用onUnbind()方法解除调用者与服务解除，服务结束时会调用onDestroy()方法。
官方文档告诉我们，Android系统会尽量保持拥有service的进程运行，只要在该service已经被启动(start)或者客户端连接(bindService)到它。当内存不足时，需要保持，拥有service的进程具有较高的优先级。
1. 如果service正在调用onCreate,onStartCommand或者onDestory方法，那么用于当前service的进程则变为前台进程以避免被killed。
2. 如果当前service已经被启动(start)，拥有它的进程则比那些用户可见的进程优先级低一些，但是比那些不可见的进程更重要，这就意味着service一般不会被killed.
3. 如果客户端已经连接到service (bindService),那么拥有Service的进程则拥有最高的优先级，可以认为service是可见的。
4. 如果service可以使用startForeground(int, Notification)方法来将service设置为前台状态，那么系统就认为是对用户可见的，并不会在内存不足时killed。
❷ 如何让Android service进程变成前台进程
Android的前台Service
Service几乎都是在后台运行的，一直以来它都是默默地做着辛苦的工作。但是Service的系统优先级还是比较低的，当系统出现内存不足情况时，就有可能会回收掉正在后台运行的Service。如果你希望Service可以一直保持运行状态，而不会由于系统内存不足的原因导致被回收，就可以考虑使用前台Service
前台Service和普通Service最大的区别就在于，它会一直有一个正在运行的图标在系统的状态栏显示，下拉状态栏后可以看到更加详细的信息，非常类似于通知的效果。当然有时候你也可能不仅仅是为了防止Service被回收才使用前台Service，有些项目由于特殊的需求会要求必须使用前台Service，比如说墨迹天气，它的Service在后台更新天气数据的同时，还会在系统状态栏一直显示当前天气的信息。
那么我们就来看一下如何才能创建一个前台Service吧，其实并不复杂，如下所示：
这里只是修改了Service中onCreate()方法的代码。可以看到，我们首先创建了一个Notification对象，然后调用了它的setLatestEventInfo()方法来为通知初始化布局和数据，并在这里设置了点击通知后就打开MainActivity。然后调用startForeground()方法就可以让MyService变成一个前台Service，并会将通知的图片显示出来。
现在重新运行一下程序， Service就会以前台Service的模式启动了，并且在系统状态栏会弹出一个通栏图标，下拉状态栏后可以看到通知的详细内容。
❸ 如何让android的service一直在后台运行
java">StartedService的生命周期：
onCreate()：创建服务
onStartCommand()：服务开始运行（在2.0以前版本中，使用onStart()回调方法）
onDestroy()：服务被停止
【详细说明：】
在程序中调用：context.startService()会触发执行Service生命周期中的onCreate()、onStartCommand()回调方法，此时服务就开始正式运行；
如果Service还没有运行，则android先调用onCreate()然后调用onStartCommand()；如果Service已经运行，则只调用onStartCommand()，所以一个Service的onStartCommand方法可能会重复调用多次；
如果在程序中调用：context.stopService()会触发执行Service生命周期中的onDestroy()回调方法，会让服务停止；
stopService()的时候直接onDestroy，如果是调用者自己直接退出而没有调用stopService()的话，Service会一直在后台运行。该Service的调用者再启动该Service后可以通过stopService关闭Service；stopSelf()
所以StartService的生命周期为：onCreate-->onStartCommand(可多次调用)-->onDestroy。
Service运行在后台，它是不可见的、无界面的程序Service运行在主线程中；最好在Service中启动新线程来运行耗时的任务
为什么不使用后台线程而使用Service？
·1、Service可以放在独立的进程中，所以更安全；
·2、使用Service可以依赖现有的binder机制，不需要在应用层面上处理线程同步的繁杂工作；
·3、系统可以重新启动异常死去的Service。
服务的分类
1本地服务2远程服务
启动服务的方法
1）、Context.startService()
调用者与服务之间没有关联，即使调用者退出，服务仍可运行
2）、Context.bindService()
调用者与服务绑定在一起，调用者一旦退出，服务也就终止
a本地服务的分类:
StartedService被启动服务
被启动的服务是由其它组件调用startService()方法而启动的，onStartCommand()被回调，除非调用stopSelf()或stopService()来停止该服务。否则该服务还可以在后台无限期运行
BoundService绑定服务
绑定服务是允许其它应用程序绑定并且与之交互的Service的实现类。为了提供绑定，必须实现onBind()回调方法。该方法返回IBinder对象，它定义了服务类与Activity交互的程序接口。
根据onStartCommand()的返回值还划分为：粘性服务和非粘性服务
·START_STICKY（常量值：1）：sticky的意思是“粘性的”。使用这个返回值时，我们启动的服务跟应用程序"粘"在一起，如果在执行完onStartCommand后，服务被异常kill掉，系统会自动重启该服务。当再次启动服务时，传入的第一个参数将为null;
·START_NOT_STICKY（常量值：2）：“非粘性的”。使用这个返回值时，如果在执行完onStartCommand后，服务被异常kill掉，系统不会自动重启该服务。
·START_REDELIVER_INTENT（常量值：3）：重传Intent。使用这个返回值时，如果在执行完onStartCommand后，服务被异常kill掉，系统会自动重启该服务，并将Intent的值传入。
b远程服务
远程服务是吧数据暴露出来由其他应用程序调用
1、StartedService的生命周期：
·onCreate()：创建服务
·onStartCommand()：服务开始运行（在2.0以前版本中，使用onStart()回调方法）
·onDestroy()：服务被停止
调用startedservice会调用服务里的onstartedcommand方法如果第一次调用会调用oncreate方法。
调用stopservice会调用服务里的ondestroy()
2、BoundService的生命周期：
·onCreate()：创建服务
·onBind()：绑定服务，服务开始运行
·onUnbind()：取消绑定
·onDestroy()：服务被停止
·在程序中调用：context.bindService()会触发执行Service生命周期中的onCreate()、onBind()回调方法，此时服务开始运行；
·onBind将返回给客户端一个IBind接口实例，IBind允许客户端回调服务的方法，比如得到Service运行的状态或其他操作。此后调用者（Context，例如Activity）会和Service绑定在一起；
·如果调用Service的调用者Context退出了，那么会依次调用Service生命周期中的onUnbind()、onDestroy()回调方法，会让服务停止；
·所以BindService的生命周期为：onCreate-->onBind(只一次，不可多次绑定)-->onUnbind-->onDestory。
·Service是不能自己启动
IntentService和Service
·生成一个默认的且与主线程互相独立的工作者线程来执行所有传送至onStartCommand()方法的Intetnt
·生成一个工作队列来传送Intent对象给你的onHandleIntent()方法，同一时刻只传送一个Intent对象，这样一来，你就不必担心多线程的问题。
·在所有的请求(Intent)都被执行完以后会自动停止服务，所以，你不需要自己去调用stopSelf()方法来停止该服务
·提供了一个onBind()方法的默认实现，它返回null
·提供了一个onStartCommand()方法的默认实现，它将Intent先传送至工作队列，然后从工作队列中每次取出一个传送至onHandleIntent()方法，在该方法中对Intent对相应的处理
IntentService使用队列的方式将请求的Intent加入队列，然后开启一个workerthread(线程)来处理队列中的Intent，对于异步的startService请求，IntentService会处理完成一个之后再处理第二个，每一个请求都会在一个单独的workerthread中处理，不会阻塞应用程序的主线程。
这里就给我们提供了一个思路，如果有耗时的操作可以在Service里面开启新线程，也可以使用IntentService来处理耗时操作。但你若是想在Service中让多个线程并发的话，就得使用第一种方法，在Service内部起多个线程，但是这样的话，你可要处理好线程的同步。
❹ Android 之 Service（一）启动，绑定服务
Service（服务）一个运行在后台执行长时间运行的操作组件，它不提供任何用户界面，作为与Activity同级的组件，它依旧是运行在主线程中。
其它组件可以启动一个Service，当这个Service启动之后便会在后台执行，这里需要注意，由于是在主线程中，所以我们需要另外开启一个线程来执行我们的耗时操作。
此外，一个组件还可以与一个Service进行绑定来实现组件之间的交互，甚至可以执行IPC（Inter-Process Communication）进程间通信。
Service可以在后台执行很多任务，比如处理网络事务，播放音乐，文件读写或者与一个内容提供者交互，等等。
本地服务（Local）
该服务依附在主进程上而不是独立的进程，这样在一定程度上节约了资源，另外本地服务因为是在同一进程因此不需要IPC，也不需要AIDL。相应bindService会方便很多，当主进程被Kill后，服务便会终止。一般使用在音乐播放器播放等不需要常驻的服务。
远程服务(Remote Service)
该服务是独立的进程，对应进程名格式为所在包名加上你指定的android:process字符串。一般定义方式 android:process=":service" 由于是独立的进程，因此在Activity所在进程被Kill的时候，该服务依然在运行，不受其他进程影响，有利于为多个进程提供服务具有较高的灵活性。由于是独立的进程，会占用一定资源，并且使用AIDL进行IPC比较麻烦。一般用于系统的Service，这种Service是常驻的。
startService启动的服务
用于启动一个服务执行后台任务，不与组件进行通信，停止服务使用stopService。 当一个应用组件比如activity通过调用startService()来启动一个服务的时候，服务便处于启动状态。一旦启动，服务可以在后台无限期地运行下去，即使当启动它的组件已经销毁。通常情况下，一个启动的service执行一个单一的操作并且不会返回任何结果给调用者。
bindService启动的服务
用于启动的服务需要进行通信。停止服务使用unbindService。 当一个应用组件通过调用bindService()来与一个服务绑定时，服务便处于绑定状态。一个绑定的服务提供了一个客户端-服务器端接口来允许组件与服务进行交互，发送请求，得到结果甚至通过IPC进程间通信来完成操作。只有当其它组件与服务进行绑定时，服务才会处于绑定状态。多个组件可以同时与服务绑定，但是当他们全部都解除绑定时，服务就会销毁。
2.BindService：
如果一个Service在某个Activity中被调用bindService方法启动，不论bindService被调用几次，Service的 onCreate 方法只会执行一次，同时 onStartCommand 方法始终不会调用。当建立连接后，Service会一直运行，除非调用unbindService来接触绑定、断开连接或调用该Service的Context不存在了（如Activity被Finish——即通过bindService启动的Service的生命周期依附于启动它的Context），系统在这时会自动停止该Service。
3.StartService AND BindService：
当一个Service在被启动(startService 的同时又被绑定(bindService )，该Service将会一直在后台运行，并且不管调用几次， onCreate 方法始终只会调用一次， onStartCommand 的调用次数与startService 调用的次数一致（使用bindService 方法不会调用 onStartCommand ）。同时，调用unBindService 将不会停止Service，必须调用stopService 或Service自身的stopSelf 来停止服务。
4.停止Service：
当一个服务被终止（stopService 、stopSelf 、unbindService ）时， onDestory 方法将会被调用——所以我们需要在该方法中清除一些工作（依附该Service生命周期上的，比如：停止在Service中创建并运行的线程）。
1.创建服务
如果你才用的是 startService的方式那么 onBind方法可以忽略
2.注册服务
3.开启服务
start:
bind
绑定服务，一般涉及到组件或进程之间的通信，既然需要通信，那么我们肯定需要一个连接，这里ServiceConnection就是我们所需要的连接，通过Ibinder的传递，我们可以获取到Service的Ibinder对象，从而进行相关操作。
关于粘性服务，这里需要提到 Service的onStartCommand返回值
andorid:name
adroid:exported
android:enabled
android:label
android:process
android:icon
android:permission
关于服务，当我们在应用开发中，如果需要长时间的在后台运行，独立完成某一些事情的情况下，请使用Service！
此文综合： http://www.jianshu.com/p/1e49e93c3ec8 以及自己的一些问题看法，用作学习，回顾之用。
Service 前台服务
请参看 紫豪 http://www.jianshu.com/p/5505390503fa
❺ 如何让Android service进程变成前台进程
这里只是修改了Service中onCreate()方法的代码。可以看到，我们首先创建了一个Notification对象，然后调用了它的setLatestEventInfo()方法来为通知初始化布局和数据，并在这里设置了点击通知后就打开MainActivity。然后调用startForeground()方法就可以让MyService变成一个前台Service，并会将通知的图片显示出来。
现在重新运行一下程序， Service就会以前台Service的模式启动了，并且在系统状态栏会弹出一个通栏图标，下拉状态栏后可以看到通知的详细内容
❻ android应用进程关闭怎么启动service
Service不是分离开的进程，除非其他特殊情况，它不会运行在自己的进程，而是作为启动运行它的进程的一部分。
Service不是线程，这意味着它将在主线程里劳作。
启动service有两种方法：
Context.startService()调用者与服务之间没有关联，即使调用者退出，服务仍可运行
Context.bindService() 调用者与服务绑定在一起，调用者一旦退出，服务也就终止。
❼ 如何让android的service一直在后台运行
1.把service和activity分开，让service开机启动。设置一个broadcastreceiver接受开机信号，使用RECEIVE_BOOT_COMPLETED的permission，然后启动service。activity启动后绑定到service上，通过ipc机制通信，acitivity结束后松绑。注意安装后要手动启动service，不会自动启动，之后重启手机后才会随开机启动。2.在内存低的时候系统会自动清理进程，这时候后台service可能会被杀掉。可以在onStartCommand中返回START_STICKY，这样系统有足够多资源的时候，就会重新开启service。3.以上不需要NDK，直接用SDK开发就可以了。Android一直运行的后台服务是不存在的，而且也不是最佳实践，因为一直运行的后台服务会耗费大量系统资源，影响其他程序的响应从而影响到用户体验。可以考虑使用如下几种方案来达到一直运行的效果。1.调用startForeground方法，android:.使用AlarmManager发送定时任务：DiamondsAreForever.ServicesAreNot.我现在也遇到这个问题，我想楼主之所以出现这个问题的原因是，你在Activitiy中创建的Service运行在当前进程中，当你把这个Activitiy的进程杀掉之后，自然这个服务也就停止了。所以我的建议是在startService的时候，让这个Service运行在与该Activity不同的进程中（可以startService或者开机时创建一个新的进程）。实际上就是Linux里面的进程操作。可以使用NDK开发，用C或者C++新建一个进程来运行自己的服务，并提高进程优先级，避免被清理掉（我猜测 和 的推送服务，或许是这么实现的）。有一种做法是开两个进程来相互监督，一旦其中一个进程被停止，另一个检测到后，立即或稍后重启另一个进程。这里可以效仿这种做法。可以开两个进程，一个用来做前台，另一个负责运行服务，后者没有activity，由前者初始化并启动，这样，当前台进程被关闭时，服务并不被关闭
❽ Android 启动后台运行程序(Service)
Android开发中，当需要创建在后台运行的程序的时候，就要使用到Service。Service 可以分为有无限生命和有限生命两种。特别需要注意的是Service跟Activities是不同的（简单来说可以理解为后台与前台的区别），例如，如果需要使用Service的话，需要调用startService(),从而利用startService()去调用Service中的OnCreate()和onStart()方法来启动一个后台的Service。 启动一个Service的过程如下：context.startService() ->onCreate()- >onStart()->Service running其中onCreate()可以进行一些服务的初始化工作，onStart()则启动服务。 停止一个Service的过程如下：context.stopService() | ->onDestroy() ->Service stop 接下来的实例是一个利用后台服务播放音乐的小例子，点击start运行服务，点击stop停止服务。ServicesDemo.java（是一个Activity）
package com.android.myservice;
import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
public class ServiceDemo extends Activity implements OnClickListener {
private static final String TAG = "ServiceDemo";
Button buttonStart, buttonStop;
}
除此之外还要在Manifest里面声明服务:
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android=" http://schemas.android.com/apk/res/android "
package="com.android.myservice">
<application android:label="@string/app_name">
<activity android:name=".ServiceDemo" android:label="@string/app_name">
<intent-filter>
<action android:name="android.intent.action.MAIN"/>
<category android:name="android.intent.category.LAUNCHER"/>
</intent-filter>
</activity>
<service android:enabled="true" android:name=".MyService"/>
</application>
</manifest>
定义Service(MyService.java
package com.android.myservice;
import android.app.Service;
import android.content.Intent;
import android.media.MediaPlayer;
import android.os.IBinder;
import android.util.Log;
import android.widget.Toast;
public class MyService extends Service {
private static final String TAG = "MyService";
MediaPlayer player;
}
layout文件夹中是main.xml
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android=" http://schemas.android.com/apk/res/android "
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:gravity="center">
<TextView
android:layout_width="fill_parent"
android:layout_height="wrap_content" android:text="@string/services_demo" android:gravity="center" android:textSize="20sp" android:padding="20dp"/>
<Button android:layout_width="wrap_content" android:layout_height="wrap_content" android:id="@+id/buttonStart" android:text="@string/start"></Button>
<Button android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="@string/stop" android:id="@+id/buttonStop"></Button>
</LinearLayout>
values 文件夹中是strings.xml
<?xml version="1.0" encoding="utf-8"?>
<resources>
<string name="start">Start</string>
<string name="stop">Stop</string>
<string name="services_demo">Service Demo</string>
</resources>
❾ Android中的Service到底起什么作用
Service 是android的一种机制，当它运行的时候如果是Local Service，那么对应的 Service 是运行在主进程的 main 线程上的。如：onCreate，onStart 这些函数在被系统调用的时候都是在主进程的 main 线程上运行的。如果是Remote Service，那么对应的 Service 则是运行在独立进程的 main 线程上。因此请不要把 Service 理解成线程，它跟线程半毛钱的关系都没有！
既然这样，那么我们为什么要用 Service 呢？其实这跟 android 的系统机制有关，我们先拿 Thread 来说。Thread 的运行是独立于 Activity 的，也就是说当一个 Activity 被 finish 之后，如果你没有主动停止 Thread 或者 Thread 里的 run 方法没有执行完毕的话，Thread 也会一直执行。因此这里会出现一个问题：当 Activity 被 finish 之后，你不再持有该 Thread 的引用。另一方面，你没有办法在不同的 Activity 中对同一 Thread 进行控制。
举个例子：如果你的 Thread 需要不停地隔一段时间就要连接服务器做某种同步的话，该 Thread 需要在 Activity 没有start的时候也在运行。这个时候当你 start 一个 Activity 就没有办法在该 Activity 里面控制之前创建的 Thread。因此你便需要创建并启动一个 Service ，在 Service 里面创建、运行并控制该 Thread，这样便解决了该问题（因为任何 Activity 都可以控制同一 Service，而系统也只会创建一个对应 Service 的实例）。
因此你可以把 Service 想象成一种消息服务，而你可以在任何有 Context 的地方调用 Context.startService、Context.stopService、Context.bindService，Context.unbindService，来控制它，你也可以在 Service 里注册 BroadcastReceiver，在其他地方通过发送 broadcast 来控制它，当然这些都是 Thread 做不到的。