คลาสตัวจัดการนี้ควรเป็นแบบคงที่หรืออาจเกิดการรั่วไหล: IncomingHandler

ฉันกำลังพัฒนาแอปพลิเคชัน Android 2.3.3 พร้อมบริการ ฉันมีสิ่งนี้ในบริการที่จะสื่อสารกับกิจกรรมหลัก:

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

และที่นี่final Messenger mMessenger = new Messenger(new IncomingHandler());ฉันได้รับคำเตือนจากผ้าสำลี:

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

มันหมายความว่าอะไร?

ถ้าIncomingHandlerคลาสไม่คงที่จะมีการอ้างอิงถึงServiceวัตถุของคุณ

Handler วัตถุสำหรับชุดข้อความเดียวกันทั้งหมดจะแชร์วัตถุ Looper ทั่วไปซึ่งพวกเขาโพสต์ข้อความไปยังและอ่านจาก

เนื่องจากข้อความมีเป้าหมายHandlerตราบใดที่มีข้อความที่มีตัวจัดการเป้าหมายในคิวข้อความตัวจัดการไม่สามารถรวบรวมขยะได้ หากตัวจัดการไม่คงที่คุณServiceหรือActivityไม่สามารถรวบรวมขยะแม้หลังจากถูกทำลาย

สิ่งนี้อาจนำไปสู่การรั่วไหลของหน่วยความจำบางครั้งอย่างน้อย - ตราบใดที่ข้อความยังคงอยู่ในคิว นี่ไม่ใช่ปัญหามากเว้นแต่คุณจะโพสต์ข้อความที่ล่าช้าเป็นเวลานาน

คุณสามารถทำให้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);
         }
    }
}

ดูโพสต์นี้โดย Romain Guy สำหรับการอ้างอิงเพิ่มเติม

อย่างที่คนอื่น ๆ ได้กล่าวถึง Lint warning นั้นเป็นเพราะหน่วยความจำที่อาจรั่ว คุณสามารถหลีกเลี่ยงคำเตือน Lint ได้โดยการส่งผ่านHandler.Callbackเมื่อสร้างHandler (เช่นคุณไม่ได้คลาสย่อยHandlerและไม่มีHandlerคลาสภายในที่ไม่คงที่):

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

ตามที่ฉันเข้าใจแล้วนี่จะไม่หลีกเลี่ยงการรั่วไหลของหน่วยความจำที่อาจเกิดขึ้น Messageวัตถุถือการอ้างอิงไปยังmIncomingHandlerวัตถุที่มีการอ้างอิงHandler.Callbackวัตถุที่ถือการอ้างอิงไปยังServiceวัตถุ ตราบใดที่มีข้อความในLooperคิวข้อความServiceจะไม่เป็น GC อย่างไรก็ตามมันจะไม่เป็นปัญหาร้ายแรงเว้นแต่คุณจะมีข้อความล่าช้านานในคิวข้อความ

นี่คือตัวอย่างทั่วไปของการใช้การอ้างอิงแบบอ่อนและคลาสตัวจัดการแบบสแตติกเพื่อแก้ไขปัญหา (ตามที่แนะนำในเอกสารประกอบ 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);
  }
}

วิธีนี้ใช้งานได้ดีสำหรับฉันรักษาความสะอาดของรหัสโดยรักษาตำแหน่งที่คุณจัดการข้อความไว้ในคลาสภายในของตัวเอง

ตัวจัดการที่คุณต้องการใช้

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

ชั้นใน

class IncomingHandlerCallback implements Handler.Callback{

        @Override
        public boolean handleMessage(Message message) {

            // Handle message code

            return true;
        }
}

ด้วยความช่วยเหลือของคำตอบของ @ Sogger ฉันได้สร้างตัวจัดการทั่วไป:

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

อินเทอร์เฟซ:

public interface MessageHandler {

    void handleMessage(Message msg);

}

ฉันใช้มันดังนี้ แต่ฉันไม่แน่ใจ 100% ว่านี่ปลอดภัยหรือไม่ บางทีใครบางคนสามารถแสดงความคิดเห็นเกี่ยวกับสิ่งนี้:

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

    ...

}

ฉันไม่แน่ใจ แต่คุณสามารถลองใช้ intialising handler เป็น null ใน onDestroy ()

ฉันสับสน ตัวอย่างที่ฉันพบหลีกเลี่ยงคุณสมบัติคงที่ทั้งหมดและใช้เธรด 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();
                }
            }
        };
    }

สิ่งที่ฉันชอบเกี่ยวกับวิธีนี้คือไม่มีปัญหาในการพยายามผสมตัวแปรคลาสและเมธอด