處理程序和內存泄漏的Android

Question

請看看下面的代碼：

public class MyGridFragment extends Fragment{ 

    Handler myhandler = new Handler() { 
    @Override 
    public void handleMessage(Message message) { 
     switch (message.what) { 
     case 2: { 

      ArrayList<HashMap<String,String>> theurls = (ArrayList<HashMap<String,String>>) message.obj; 
      urls.addAll(theurls); 
      theimageAdapter.notifyDataSetChanged(); 
      dismissBusyDialog(); 
      break; 
     }}}}; 
     } 

當我使用的處理程序是這樣，我得到一個警告「處理程序應該是靜態的，否則很容易出現內存泄漏。」有人能告訴我什麼是最好的辦法嗎？

Answer 1

我最近在自己的代碼中更新了類似的東西。我只是將匿名處理程序類設爲受保護的內部類，並且Lint警告消失了。看看下面的代碼是否適用於您：

public class MyGridFragment extends Fragment{ 

    static class MyInnerHandler extends Handler{ 
     WeakReference<MyGridFragment> mFrag; 

     MyInnerHandler(MyGridFragment aFragment) { 
      mFrag = new WeakReference<MyGridFragment>(aFragment); 
     } 

     @Override 
     public void handleMessage(Message message) { 
      MyGridFragment theFrag = mFrag.get(); 
      switch (message.what) { 
      case 2: 
       ArrayList<HashMap<String,String>> theurls = (ArrayList<HashMap<String,String>>) message.obj; 
       theFrag.urls.addAll(theurls); 
       theFrag.theimageAdapter.notifyDataSetChanged(); 
       theFrag.dismissBusyDialog(); 
       break; 
      }//end switch 
     } 
    } 
    MyInnerHandler myHandler = new MyInnerHandler(this); 
} 

您可能需要更改放置「theFrag」的位置。因爲我只能猜測那些引用的內容。

Answer 2

根據ADT 20 Changes，它看起來應該是靜態的。

新林特檢查：

檢查，以確保片段類實例化的。如果您不小心使 片段內部類非靜態，或者忘記具有默認構造函數，那麼當系統嘗試在配置更改後重新實例化片段時，可能會遇到運行時 錯誤。

查找處理程序泄漏：此檢查可確保處理程序內部類不保留對其外部類的隱式引用 。

Answer 3

如果您閱讀有關AccountManager或PendingIntent的文檔，您將看到有些方法將Handler作爲參數之一。

For example：

• onFinished - 回電話時發送已完成，或者爲null，沒有回調的對象。
• 處理程序 - 處理程序標識應該發生回調的線程。如果爲null，則回調將從進程的線程池中發生。

想象一下情況。某些Activity調用PendingIntent.send（...）並放置Handler的非靜態內部子類。然後活動被破壞。但內心階層的生活。

內部類仍然存在一個被破壞活動的鏈接，它不能被垃圾收集。

如果你不打算髮送你的處理程序到這種方法，你沒有什麼可擔心的。

Answer 4

我遇到了同樣的問題，我發現它是這個主題有很多問題和答案很少。我的解決方法很簡單，我希望它可以幫助別人：

/* BEFORE */ 
private Handler mHandler= new Handler() { 
     @Override public void handleMessage(Message msg) { 
     this.doSomething(); 
    }; 
}; 

我們可以創建一個僅運行一個Runnable靜態處理程序的子類。實際的處理程序實例將通過可以訪問實例變量的runnable知道該怎麼做。

/* AFTER */ 
static class RunnableHandler extends Handler { 
    private Runnable mRunnable; 
    public RunnableHandler(Runnable runnable) { 
     mRunnable = runnable; 
    } 
    @Override public void handleMessage(Message msg) { 
     mRunnable.run(); 
    }; 
} 
private RunnableHandler mHandler = new RunnableHandler(new Runnable() { 
    @Override public void run() { 
     this.doSomething(); 
    } }); 

警告消失，而功能性是相同的。

Answer 5

這是我可以使用的一個有點有用的小班。可悲的是它仍然很冗長，因爲你不能擁有匿名的靜態內部類。

import java.lang.ref.WeakReference; 
import android.os.Handler; 
import android.os.Message; 

/** A handler which keeps a weak reference to a fragment. According to 
* Android's lint, references to Handlers can be kept around for a long 
* time - longer than Fragments for example. So we should use handlers 
* that don't have strong references to the things they are handling for. 
* 
* You can use this class to more or less forget about that requirement. 
* Unfortunately you can have anonymous static inner classes, so it is a 
* little more verbose. 
* 
* Example use: 
* 
* private static class MsgHandler extends WeakReferenceHandler<MyFragment> 
* { 
*  public MsgHandler(MyFragment fragment) { super(fragment); } 
* 
*  @Override 
*  public void handleMessage(MyFragment fragment, Message msg) 
*  { 
*   fragment.doStuff(msg.arg1); 
*  } 
* } 
* 
* // ... 
* MsgHandler handler = new MsgHandler(this); 
*/ 
public abstract class WeakReferenceHandler<T> extends Handler 
{ 
    private WeakReference<T> mReference; 

    public WeakReferenceHandler(T reference) 
    { 
     mReference = new WeakReference<T>(reference); 
    } 

    @Override 
    public void handleMessage(Message msg) 
    { 
     if (mReference.get() == null) 
      return; 
     handleMessage(mReference.get(), msg); 
    } 

    protected abstract void handleMessage(T reference, Message msg); 
}