一个小补语是:

我的目标是知道一个服务是否在运行，如果它没有运行。

调用bindService或调用一个可以被服务捕获的意图不是一个好主意，因为它会在服务未运行时启动服务。

因此，正如miracle2k所建议的，最好是在服务类中有一个静态字段，以知道服务是否已经启动。

为了使它更简洁，我建议用非常非常懒惰的抓取来转换单例中的服务:也就是说，通过静态方法完全没有实例化单例实例。service/singleton的静态getInstance方法只返回已经创建的单例实例。但它并不实际启动或实例化单例本身。服务只能通过正常的服务启动方法启动。

然后，修改单例设计模式，将令人困惑的getInstance方法重命名为类似isInstanceCreated(): boolean方法的方法会更加清晰。

代码如下所示:

public class MyService extends Service
{
   private static MyService instance = null;

   public static boolean isInstanceCreated() {
      return instance != null;
   }//met

   @Override
   public void onCreate()
   {
      instance = this;
      ....
   }//met

   @Override
   public void onDestroy()
   {
      instance = null;
      ...
   }//met
}//class

这个解决方案很优雅，但只有当你可以访问服务类时才有意义，而且只适用于服务的应用程序/包旁边的类。如果你的类在服务应用程序/包之外，那么你可以用Pieter-Jan Van Robays强调的限制来查询ActivityManager。

检测服务是否正在运行的唯一有效/最快/干净的方法是创建PING/PONG功能。

在服务内部实现Messenger或AIDL方法:isAlive()——它返回服务的状态。

不要实现广播，因为它们可能被错过。

在kotlin中，你可以在伴侣对象中添加布尔变量，并从任何你想要的类中检查它的值:

companion object{
     var isRuning = false

}

在创建和销毁服务时更改它的值

 override fun onCreate() {
        super.onCreate()
        isRuning = true
    }

override fun onDestroy() {
    super.onDestroy()
    isRuning = false
    }

在你的服务子类中，使用一个静态布尔值来获取服务的状态，如下所示。

MyService.kt

class MyService : Service() {
    override fun onCreate() {
        super.onCreate()
        isServiceStarted = true
    }
    override fun onDestroy() {
        super.onDestroy()
        isServiceStarted = false
    }
    companion object {
        var isServiceStarted = false
    }
}

MainActivity.kt

class MainActivity : AppCompatActivity(){
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val serviceStarted = FileObserverService.isServiceStarted
        if (!serviceStarted) {
            val startFileObserverService = Intent(this, FileObserverService::class.java)
            ContextCompat.startForegroundService(this, startFileObserverService)
        }
    }
}

另一种方法是使用kotlin。启发了其他用户的回答

fun isMyServiceRunning(serviceClass: Class<*>): Boolean {
    val manager = getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
    return manager.getRunningServices(Integer.MAX_VALUE)
            .any { it.service.className == serviceClass.name }
}

作为kotlin扩展

fun Context.isMyServiceRunning(serviceClass: Class<*>): Boolean {
    val manager = this.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
    return manager.getRunningServices(Integer.MAX_VALUE)
            .any { it.service.className == serviceClass.name }
}

使用

context.isMyServiceRunning(MyService::class.java)

这是我提出的一个很好的解决方案，但它只适用于运行在单独进程中的服务。这可以通过在manifest中添加一个android:process属性来实现。

<service
        android:name=".ExampleService"
        android:process="com.example.service"
        ...

现在，您的服务将运行在具有给定名称的单独进程中。从你的应用程序你可以打电话

val activityManager = context.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
activityManager.runningAppProcesses.any { it.processName == "com.example.service" }

如果服务正在运行，则返回true，否则返回false。

重要提示:请注意，它将显示您的服务是何时启动的，但当您禁用它时(即在系统从它解除绑定后)，该进程仍然是活跃的。所以你可以简单地强制移除它:

override fun onUnbind(intent: Intent?): Boolean {
    stopSelf()
    return super.onUnbind(intent)
}

override fun onDestroy() {
    super.onDestroy()
    killProcess(Process.myPid())
}

然后它就完美地工作了。