Android教程網
  1. 首頁
  2. Android 技術
  3. Android 手機
  4. Android 系統教程
  5. Android 游戲
 Android教程網 >> Android技術 >> Android開發 >> 關於android開發 >> Android開發筆記——常見BUG類型之內存洩露與線程安全,androidbug

Android開發筆記——常見BUG類型之內存洩露與線程安全,androidbug

編輯:關於android開發

Android開發筆記——常見BUG類型之內存洩露與線程安全,androidbug


 

本文內容來源於最近一次內部分享的總結,沒來得及詳細整理,見諒。

本次分享主要對內存洩露線程安全這兩個問題進行一些說明,內部代碼掃描發現的BUG大致分為四類:1)空指針;2)除0;3)內存、資源洩露;4)線程安全。第一、二個問題屬於編碼考慮不周,第三、四個問題則需要更深入的分析。


一、內存洩露

1、很抱歉,”XXX”已停止運行。OOM?

怎樣才能讓app報OOM呢?最簡單的辦法如下:

Bitmap bt1 = BitmapFactory.decodeResource(this.getResources(), R.drawable.image);
Bitmap bt2 = BitmapFactory.decodeResource(this.getResources(), R.drawable.image);
Bitmap btn = ...

 

2、查看內存占用

  • 命令行:adb shell dumpsys meminfo packageName

  • 通過Android Studio的Memory Monitor查看內存中Dalvik Heap的實時變化

 

3、發生內存洩露的條件

首先,每個app有最大內存限制。

ActivityManager activityManager = (ActivityManager) context.getSystemServiceContext.ACTIVITY_SERVICE);
activityManager.getMemoryClass();
 
getMemoryClass()取到的是最大內存資源。Android中的堆內存分為Native Heap和Dalvik Heap。C/C++申請的內存空間在Native Heap中,Java申請的內存空間則在Dalvik Heap中。對於head堆的大小限制,可以查看/system/build.prop文件:
 
dalvik.vm.heapstartsize=8m
dalvik.vm.heapgrowthlimit=96m
dalvik.vm.heapsize=256m

注意:

heapsize參數表示單個進程heap可用的最大內存,但如果存在以下參數”dalvik.vm.headgrowthlimit =96m”表示單個進程heap內存被限定在96m,即程序運行過程實際只能使用96m內存。

如果申請的內存資源超過上述限制,系統就會拋出OOM錯誤。

 

4、常見避免OOM的措施

以下主要從四個方面總結常見的措施:1)減小對象的內存占用;2)內存對象的重復利用;3)避免對象的內存洩露;4)內存使用策略優化。

4.1 減小對象的內存占用

  • 使用ArrayMap/SparseArray而不是HashMap等傳統數據結構。
    • 參考鏈接:Android內存優化(使用SparseArray和ArrayMap代替HashMap)
  • 在Android中避免使用枚舉。
  • 減小Bitmap對象的內存占用。inSampleSize和decode format。

4.2 內存對象的重復利用

  • ListView/GridView等出現大量重復子組件的視圖裡面對ConvertView的復用
  • 使用LRU機制緩存Bitmap
  • 避免在onDraw方法裡面執行對象的創建
  • 使用StringBuilder來替代頻繁的”+”

4.3 避免對象的內存洩露

4.1和4.2都是比較常規的措施,4.3需要重點關注。

1)Activity洩露

導致Activity洩露的原因較多,下面列舉一些比較常見的。從原理上主要分為兩類:i)靜態對象;ii)this$0

  • Activity被static變量引用。這段代碼來自於我們的Crash上傳
    private static Map<ComponentName, ExceptionHandler> configMap = 
                            new HashMap<ComponentName, ExceptionHandler>();
    public static void setActivity(final Activity activity, boolean send2Server) {
        Log.d(TAG, "bind exception handler : " + activity.getComponentName().getClassName());
        //上下文初始化
        SDKContext.init(activity.getApplication());
        init(activity.getApplication());
        ExceptionHandler exceptionHandler = new ExceptionHandler(
                            activity, send2Server, Thread.getDefaultUncaughtExceptionHandler());
        configMap.put(activity.getComponentName(), exceptionHandler);
        Thread.setDefaultUncaughtExceptionHandler(exceptionHandler);
    }

下面是通過MAT分析一個Activity洩露的截圖:
 

  • 內部類引用導致Activity的洩漏
    最典型的場景是Handler導致的Activity洩漏,如果Handler中有延遲的任務或者是等待執行的任務隊列過長,都有可能因為Handler繼續執行而導致Activity發生洩漏。此時的引用關系鏈是Looper -> MessageQueue -> Message -> Handler -> Activity。為了解決這個問題,可以在UI退出之前,執行remove Handler消息隊列中的消息與runnable對象。或者是使用Static + WeakReference的方式來達到斷開Handler與Activity之間存在引用關系的目的。
    可參考鏈接:線程通信

2)考慮使用Application Context而不是Activity Context

對於大部分非必須使用Activity Context的情況(Dialog的Context就必須是Activity Context),我們都可以考慮使用Application Context而不是Activity的Context,這樣可以避免不經意的Activity洩露。

3)注意臨時Bitmap對象的及時回收

雖然在大多數情況下,我們會對Bitmap增加緩存機制,但是在某些時候,部分Bitmap是需要及時回收的。例如臨時創建的某個相對比較大的bitmap對象,在經過變換得到新的bitmap對象之後,應該盡快回收原始的bitmap,這樣能夠更快釋放原始bitmap所占用的空間。

4)內存占用監控
通過Runtime獲取maxMemory,而maxMemory-totalMemory即為剩余可使用的dalvik內存。定期檢查這個值,達到80%就去釋放各種cache資源(bitmap的cache)。

/**
 * Returns the maximum number of bytes the heap can expand to. See {@link #totalMemory} for the
 * current number of bytes taken by the heap, and {@link #freeMemory} for the current number of
 * those bytes actually used by live objects.
 */
int maxMemory = Runtime.getRuntime().maxMemory()); // 應用程序最大可用內存
/**
 * Returns the number of bytes taken by the heap at its current size. The heap may expand or
 * contract over time, as the number of live objects increases or decreases. See
 * {@link #maxMemory} for the maximum heap size, and {@link #freeMemory} for an idea of how much
 * the heap could currently contract.
 */
long totalMemory = Runtime.getRuntime().totalMemory()); // 應用程序已獲得內存
/**
 * Returns the number of bytes currently available on the heap without expanding the heap. See
 * {@link #totalMemory} for the heap's current size. When these bytes are exhausted, the heap
 * may expand. See {@link #maxMemory} for that limit.
 */
long freeMemory = Runtime.getRuntime().freeMemory()); // 應用程序已獲得內存中未使用內存

5)注意Cursor對象是否及時關閉

在程序中我們經常會進行查詢數據庫的操作,但時常會存在不小心使用Cursor之後沒有及時關閉的情況。這些Cursor的洩露,反復多次出現的話會對內存管理產生很大的負面影響,我們需要謹記對Cursor對象的及時關閉。

4.4 內存使用策略優化

  • 謹慎使用large heap
  • 綜合考慮設備內存阈值與其他因素設計合適的緩存大小
  • onLowMemory()/onTrimMemory(int)
  • 資源文件需要選擇合適的文件夾進行存放
  • Try catch某些大內存分配的操作
  • 謹慎使用static對象
  • 優化布局層次,減少內存消耗
  • 謹慎使用多進程
  • 謹慎使用依賴注入框架
  • 使用ProGuard來剔除不需要的代碼
  • 謹慎使用第三方libraries
  • 考慮不同的實現方式來優化內存占用

二、線程安全

1、下面的方法是線程安全的嗎?

class MyCounter {
    private static int counter = 0;
    public static int getCount() {
        return counter++;
    }
}

怎樣使上述方法線程安全?
 

2、Java中的線程安全

怎樣保持在多線程環境下的數據一致性,Java提供了多種方法實現:

2.1 synchronized

JVM保證被synchronized關鍵字修飾的代碼段在同一時間只能被一個線程訪問,內部通過對對象加鎖來實現的。當方法被synchronized修飾時,鎖加在對象上;當方法同時為static時,鎖加在類上。從性能的角度來講,一般不建議直接將鎖加在類上,這樣會使得類的所有對象的該方法均為synchronized的。

從之前掃描的問題來看,在編寫synchronized程序時主要有兩點需要注意:

  • synchronized需要創建基於對象或者類的鎖,所以不能在構造器或者變量上加鎖。
  • synchronized造成死鎖。

1) 鎖加在哪裡?

List<ResultPoint> currentPossible = possibleResultPoints;
List<ResultPoint> currentLast = lastPossibleResultPoints;
int frameLeft = frame.left;
int frameTop = frame.top;
if (currentPossible.isEmpty()) {
    lastPossibleResultPoints = null;
} else {
    possibleResultPoints = new ArrayList<>(5);
    lastPossibleResultPoints = currentPossible;
    paint.setAlpha(CURRENT_POINT_OPACITY);
    paint.setColor(resultPointColor);
    synchronized (currentPossible) {
        for (ResultPoint point : currentPossible) {
            canvas.drawCircle(frameLeft
                    + (int) (point.getX() * scaleX), frameTop
                    + (int) (point.getY() * scaleY), POINT_SIZE,
                    paint);
        }
    }
}

上述方法中,possibleResultPoints的創建沒有采用同步措施,需要使用Collections.synchronizedXxx

List<MyType> list = Collections.synchronizedList(new ArrayList(<MyType>));
...
synchronized(list){
    for(MyType m : list){
        foo(m);
        m.doSomething();
    }
}

一般比較推薦創建一個虛擬的對象專門用於獲取鎖。
//dummy object variable for synchronization
private Object mutex=new Object();
...
//using synchronized block to read, increment and update count value synchronously
synchronized (mutex) {
        count++;
}

PS:直接在方法上加synchronized可能DoS攻擊喔,舉個栗子:

public class MyObject {
    // Locks on the object's monitor
    public synchronized void doSomething() { 
    // ...
    }
}
// 黑客的代碼
MyObject myObject = new MyObject();
synchronized (myObject) {
    while (true) {
        // Indefinitely delay myObject
        Thread.sleep(Integer.MAX_VALUE); 
    }
}

黑客的代碼獲取了MyObject對象的鎖,導致doSomething死鎖,從而引發Denial of Service。

public class MyObject {
    //locks on the class object's monitor
    public static synchronized void doSomething() { 
    // ...
    }
}
// 黑客的代碼
synchronized (MyObject.class) {
    while (true) {
        Thread.sleep(Integer.MAX_VALUE); // Indefinitely delay MyObject
    }
}

2) 死鎖。

public class ThreadDeadlock {
    public static void main(String[] args) throws InterruptedException {
        Object obj1 = new Object();
        Object obj2 = new Object();
        Object obj3 = new Object();
        Thread t1 = new Thread(new SyncThread(obj1, obj2), "t1");
        Thread t2 = new Thread(new SyncThread(obj2, obj3), "t2");
        Thread t3 = new Thread(new SyncThread(obj3, obj1), "t3");
        t1.start();
        Thread.sleep(5000);
        t2.start();
        Thread.sleep(5000);
        t3.start();
    }
}
class SyncThread implements Runnable{
    private Object obj1;
    private Object obj2;
    public SyncThread(Object o1, Object o2){
        this.obj1=o1;
        this.obj2=o2;
    }
    @Override
    public void run() {
        String name = Thread.currentThread().getName();
        System.out.println(name + " acquiring lock on "+obj1);
        synchronized (obj1) {
         System.out.println(name + " acquired lock on "+obj1);
         work();
         System.out.println(name + " acquiring lock on "+obj2);
         synchronized (obj2) {
            System.out.println(name + " acquired lock on "+obj2);
            work();
        }
         System.out.println(name + " released lock on "+obj2);
        }
        System.out.println(name + " released lock on "+obj1);
        System.out.println(name + " finished execution.");
    }
    private void work() {
        try {
            Thread.sleep(30000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

上述代碼會輸出什麼呢?

  1. 上一頁:
  2. 下一頁:
熱門文章
閱讀排行版
Copyright © Android教程網 All Rights Reserved