Kelas Handler ini harus statis atau kebocoran mungkin terjadi: IncomingHandler

Saya sedang mengembangkan aplikasi Android 2.3.3 dengan sebuah layanan. Saya memiliki ini di dalam layanan itu untuk berkomunikasi dengan aktivitas Utama:

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());
    [ ... ]
}

Dan di sini,, final Messenger mMessenger = new Messenger(new IncomingHandler());saya mendapatkan peringatan Lint berikut:

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

Apa artinya?

Jika IncomingHandlerkelas tidak statis, itu akan memiliki referensi ke Serviceobjek Anda .

Handler objek untuk utas yang sama semua berbagi objek Looper umum, yang mereka kirimi pesan dan baca.

Karena pesan mengandung target Handler, selama ada pesan dengan target handler dalam antrian pesan, handler tidak dapat dikumpulkan sebagai sampah. Jika pawang tidak statis, Anda Serviceatau Activitytidak dapat mengumpulkan sampah, bahkan setelah dihancurkan.

Hal ini dapat menyebabkan kebocoran memori, setidaknya untuk beberapa waktu - selama pesan tetap dalam antrian. Ini tidak banyak masalah kecuali Anda mengirim pesan yang lama tertunda.

Anda dapat membuat IncomingHandlerstatis dan memiliki WeakReferencelayanan Anda:

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

Lihat posting ini oleh Romain Guy untuk referensi lebih lanjut

Seperti orang lain telah menyebutkan peringatan Lint adalah karena potensi kebocoran memori. Anda dapat menghindari peringatan Lint dengan melewatkan Handler.Callbackketika membangun Handler(yaitu Anda tidak subkelas Handlerdan tidak ada Handlerkelas dalam non-statis):

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

Seperti yang saya pahami, ini tidak akan menghindari potensi kebocoran memori. Messageobjek memegang referensi ke mIncomingHandlerobjek yang memegang referensi Handler.Callbackobjek yang memegang referensi ke Serviceobjek. Selama ada pesan dalam Looperantrian pesan, maka Servicetidak akan menjadi GC. Namun, itu tidak akan menjadi masalah serius kecuali jika Anda memiliki pesan lama dalam antrian pesan.

Berikut adalah contoh umum menggunakan kelas referensi lemah dan pengendali statis untuk menyelesaikan masalah (seperti yang direkomendasikan dalam dokumentasi 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);
  }
}

Cara ini bekerja dengan baik untuk saya, menjaga kode tetap bersih dengan menjaga di mana Anda menangani pesan di kelas dalamnya sendiri.

Pawang yang ingin Anda gunakan

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

Kelas batin

class IncomingHandlerCallback implements Handler.Callback{

        @Override
        public boolean handleMessage(Message message) {

            // Handle message code

            return true;
        }
}

Dengan bantuan jawaban @ Sogger, saya membuat Handler generik:

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

Antarmuka:

public interface MessageHandler {

    void handleMessage(Message msg);

}

Saya menggunakannya sebagai berikut. Tapi saya tidak yakin 100% apakah ini aman bocor. Mungkin seseorang bisa berkomentar tentang ini:

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

    ...

}

Saya tidak yakin tetapi Anda dapat mencoba menginternalisasi handler ke null di onDestroy ()

Saya bingung. Contoh yang saya temukan menghindari properti statis sepenuhnya dan menggunakan utas 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();
                }
            }
        };
    }

Hal yang saya sukai dari solusi ini adalah tidak ada masalah dalam mencoba memadukan variabel kelas dan metode.