Lớp Handler này phải là tĩnh hoặc có thể xảy ra rò rỉ: In chuẩnHandler

Tôi đang phát triển ứng dụng Android 2.3.3 với một dịch vụ. Tôi có dịch vụ này bên trong dịch vụ đó để liên lạc với Hoạt động chính:

public class UDPListenerService extends Service
{
    private static final String TAG = "UDPListenerService";
    //private ThreadGroup myThreads = new ThreadGroup("UDPListenerServiceWorker");
    private UDPListenerThread myThread;
    /**
     * Handler to communicate from WorkerThread to service.
     */
    private Handler mServiceHandler;

    // Used to receive messages from the Activity
    final Messenger inMessenger = new Messenger(new IncomingHandler());
    // Use to send message to the Activity
    private Messenger outMessenger;

    class IncomingHandler extends Handler
    {
        @Override
        public void handleMessage(Message msg)
        {
        }
    }

    /**
     * Target we publish for clients to send messages to Incoming Handler.
     */
    final Messenger mMessenger = new Messenger(new IncomingHandler());
    [ ... ]
}

Và ở đây, final Messenger mMessenger = new Messenger(new IncomingHandler());tôi nhận được cảnh báo Lint sau:

This Handler class should be static or leaks might occur: IncomingHandler

Nó có nghĩa là gì?

Nếu IncomingHandlerlớp không tĩnh, nó sẽ có một tham chiếu đến Serviceđối tượng của bạn .

Handler tất cả các đối tượng cho cùng một luồng đều chia sẻ một đối tượng Looper chung, chúng gửi thông điệp đến và đọc từ đó.

Vì các tin nhắn chứa mục tiêu Handler, miễn là có các tin nhắn với trình xử lý đích trong hàng đợi tin nhắn, trình xử lý không thể được thu gom rác. Nếu xử lý không tĩnh, Servicehoặc Activitykhông thể là rác được thu thập, ngay cả sau khi bị phá hủy.

Điều này có thể dẫn đến rò rỉ bộ nhớ, ít nhất là trong một thời gian - miễn là các tin nhắn vẫn ở trong hàng đợi. Đây không phải là một vấn đề lớn trừ khi bạn gửi tin nhắn bị trì hoãn lâu.

Bạn có thể thực hiện IncomingHandlertĩnh và có một WeakReferencedịch vụ của bạn:

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);
         }
    }
}

Xem bài đăng này của Romain Guy để tham khảo thêm

Như những người khác đã đề cập cảnh báo Lint là do rò rỉ bộ nhớ tiềm năng. Bạn có thể tránh cảnh báo Lint bằng cách chuyển một Handler.Callbackkhi xây dựng Handler(nghĩa là bạn không phân lớp Handlervà không có Handlerlớp bên trong không tĩnh):

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

Theo tôi hiểu, điều này sẽ không tránh được việc rò rỉ bộ nhớ tiềm năng. Messagecác đối tượng giữ một tham chiếu đến mIncomingHandlerđối tượng chứa tham chiếu Handler.Callbackđối tượng giữ tham chiếu đến Serviceđối tượng. Miễn là có tin nhắn trong Looperhàng đợi tin nhắn, Servicesẽ không phải là GC. Tuy nhiên, đây sẽ không phải là vấn đề nghiêm trọng trừ khi bạn có tin nhắn chậm trễ trong hàng đợi tin nhắn.

Dưới đây là một ví dụ chung về việc sử dụng lớp trình xử lý tĩnh và tham chiếu yếu để giải quyết vấn đề (như được khuyến nghị trong tài liệu 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);
  }
}

Cách này hoạt động tốt với tôi, giữ sạch mã bằng cách giữ nơi bạn xử lý thư trong lớp bên trong của chính nó.

Trình xử lý bạn muốn sử dụng

Handler mIncomingHandler = new Handler(new IncomingHandlerCallback());

Lớp học bên trong

class IncomingHandlerCallback implements Handler.Callback{

        @Override
        public boolean handleMessage(Message message) {

            // Handle message code

            return true;
        }
}

Với sự giúp đỡ của câu trả lời của @ Sogger, tôi đã tạo ra một Handler chung:

public class MainThreadHandler<T extends MessageHandler> extends Handler {

    private final WeakReference<T> mInstance;

    public MainThreadHandler(T clazz) {
        // Remove the following line to use the current thread.
        super(Looper.getMainLooper());
        mInstance = new WeakReference<>(clazz);
    }

    @Override
    public void handleMessage(Message msg) {
        T clazz = mInstance.get();
        if (clazz != null) {
            clazz.handleMessage(msg);
        }
    }
}

Giao diện:

public interface MessageHandler {

    void handleMessage(Message msg);

}

Tôi đang sử dụng nó như sau. Nhưng tôi không chắc chắn 100% nếu điều này an toàn. Có lẽ ai đó có thể nhận xét về điều này:

public class MyClass implements MessageHandler {

    private static final int DO_IT_MSG = 123;

    private MainThreadHandler<MyClass> mHandler = new MainThreadHandler<>(this);

    private void start() {
        // Do it in 5 seconds.
        mHandler.sendEmptyMessageDelayed(DO_IT_MSG, 5 * 1000);
    }

    @Override
    public void handleMessage(Message msg) {
        switch (msg.what) {
            case DO_IT_MSG:
                doIt();
                break;
        }
    }

    ...

}

Tôi không chắc chắn nhưng bạn có thể thử xử lý intialising thành null trong onDestroy ()

Tôi bối rối. Ví dụ tôi tìm thấy tránh hoàn toàn thuộc tính tĩnh và sử dụng luồng UI:

    public class example extends Activity {
        final int HANDLE_FIX_SCREEN = 1000;
        public Handler DBthreadHandler = new Handler(Looper.getMainLooper()){
            @Override
            public void handleMessage(Message msg) {
                int imsg;
                imsg = msg.what;
                if (imsg == HANDLE_FIX_SCREEN) {
                    doSomething();
                }
            }
        };
    }

Điều tôi thích về giải pháp này là không có vấn đề gì khi cố gắng trộn các biến lớp và phương thức.