如果您正在使用Kotlin，只需在声明嵌套类时删除inner关键字即可。

Kotlin中的嵌套类默认情况下是静态的，使用inner声明它们使它们成为非静态的。

将嵌套的Handler子类声明更改为

class myService : Service() {

inner class IncomingHandler : Handler(Looper.getMainLooper()) {
/////
}

}

to

class myService : Service() {

class IncomingHandler : Handler(Looper.getMainLooper()) {
/////
}

}

下面是一个使用弱引用和静态处理程序类来解决问题的通用示例(在Lint文档中推荐):

public class MyClass{

  //static inner class doesn't hold an implicit reference to the outer class
  private static class MyHandler extends Handler {
    //Using a weak reference means you won't prevent garbage collection
    private final WeakReference<MyClass> myClassWeakReference; 

    public MyHandler(MyClass myClassInstance) {
      myClassWeakReference = new WeakReference<MyClass>(myClassInstance);
    }

    @Override
    public void handleMessage(Message msg) {
      MyClass myClass = myClassWeakReference.get();
      if (myClass != null) {
        ...do work here...
      }
    }
  }

  /**
   * An example getter to provide it to some external class
   * or just use 'new MyHandler(this)' if you are using it internally.
   * If you only use it internally you might even want it as final member:
   * private final MyHandler mHandler = new MyHandler(this);
   */
  public Handler getHandler() {
    return new MyHandler(this);
  }
}

如果您正在使用Kotlin，只需在声明嵌套类时删除inner关键字即可。

Kotlin中的嵌套类默认情况下是静态的，使用inner声明它们使它们成为非静态的。

将嵌套的Handler子类声明更改为

class myService : Service() {

inner class IncomingHandler : Handler(Looper.getMainLooper()) {
/////
}

}

to

class myService : Service() {

class IncomingHandler : Handler(Looper.getMainLooper()) {
/////
}

}

如果IncomingHandler类不是静态的，它将有一个对Service对象的引用。

同一个线程的处理程序对象都共享一个共同的Looper对象，它们向该对象发布消息并从中读取消息。

由于消息包含目标处理程序，只要消息队列中有带有目标处理程序的消息，处理程序就不能被垃圾收集。如果处理程序不是静态的，你的服务或活动不能被垃圾收集，即使在被销毁之后。

这可能会导致内存泄漏，至少在一段时间内——只要消息处于队列中。这不是什么大问题，除非您发布的消息延迟了很长时间。

你可以让IncomingHandler是静态的，并有一个WeakReference指向你的服务:

static class IncomingHandler extends Handler {
    private final WeakReference<UDPListenerService> mService; 

    IncomingHandler(UDPListenerService service) {
        mService = new WeakReference<UDPListenerService>(service);
    }
    @Override
    public void handleMessage(Message msg)
    {
         UDPListenerService service = mService.get();
         if (service != null) {
              service.handleMessage(msg);
         }
    }
}

请参阅罗曼盖伊的这篇文章以获得进一步的参考

我不确定，但你可以尝试初始化处理程序为空在onDestroy()

正如其他人所提到的，Lint警告是因为潜在的内存泄漏。你可以通过传递一个处理程序来避免Lint警告。回调时构造Handler(即你不子类化Handler，没有Handler非静态内部类):

Handler mIncomingHandler = new Handler(new Handler.Callback() {
    @Override
    public boolean handleMessage(Message msg) {
        // todo
        return true;
    }
});

据我所知，这并不能避免潜在的内存泄漏。消息对象持有对mIncomingHandler对象的引用，该对象持有对Handler的引用。回调对象，该对象持有对Service对象的引用。只要Looper消息队列中有消息，服务就不会被GC。但是，除非消息队列中有长时间延迟的消息，否则这不会是一个严重的问题。