Strictmode analysis activity leakage -strictmode principle (3)

3. Activity Leakage of

StrictMode about Activity There is also a leak detection .

Leaked logs :

 D/StrictMode: StrictMode policy violation: android.os.strictmode.InstanceCountViolation: class com.ifreedomer.strictmode.activity.TestLeakedActivity; instances=3; limit=1
        at android.os.StrictMode.setClassInstanceLimit(StrictMode.java:1)

StrictMode Of activity Leak detection , It's counting by reference , The general idea is divided into three steps :

1. Use map Storage Activity Class and count of Map<Class,Count>

StrictMode.java
private static final HashMap<Class, Integer> sExpectedActivityInstanceCount = new HashMap<>();

2. stay Activity The start-up phase increases the count

ActivityThread.java
/** Core implementation of activity launch. */
    private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
    
            StrictMode.incrementExpectedActivityCount(activity.getClass());
        }

3. stay Activity The recycle phase of reduces the count

ActivityThread.java
/** Core implementation of activity destroy call. */
    void performDestroyActivity(ActivityClientRecord r, boolean finishing,
            int configChanges, boolean getNonConfigInstance, String reason) {
    
        StrictMode.decrementExpectedActivityCount(activityClass);
    }

3.1 Increase the count to achieve

1. Whether the detection switch is turned on
2. Whether there is counting , If there is +1
3. Put back map

    public static void incrementExpectedActivityCount(Class klass) {
    
        if (klass == null) {
    
            return;
        }

        synchronized (StrictMode.class) {
    
            if ((sVmPolicy.mask & DETECT_VM_ACTIVITY_LEAKS) == 0) {
    
                return;
            }

            // Use the instance count from InstanceTracker as initial value.
            Integer expected = sExpectedActivityInstanceCount.get(klass);
            Integer newExpected =
                    expected == null ? InstanceTracker.getInstanceCount(klass) + 1 : expected + 1;
            sExpectedActivityInstanceCount.put(klass, newExpected);
        }
    }

3.2 Reduce count to achieve

1. Whether the detection switch is turned on
2. Whether there is counting , If there is -1
3. GC
4. Look again for references , There are several references
5. Reference is greater than count , It is considered that there is leakage

    public static void decrementExpectedActivityCount(Class klass) {
    
        if (klass == null) {
    
            return;
        }

        final int limit;
        synchronized (StrictMode.class) {
    
            if ((sVmPolicy.mask & DETECT_VM_ACTIVITY_LEAKS) == 0) {
    
                return;
            }

            Integer expected = sExpectedActivityInstanceCount.get(klass);
            int newExpected = (expected == null || expected == 0) ? 0 : expected - 1;
            if (newExpected == 0) {
    
                sExpectedActivityInstanceCount.remove(klass);
            } else {
    
                sExpectedActivityInstanceCount.put(klass, newExpected);
            }

            // Note: adding 1 here to give some breathing room during
            // orientation changes. (shouldn't be necessary, though?)
            limit = newExpected + 1;
        }

        // Quick check.
        int actual = InstanceTracker.getInstanceCount(klass);
        if (actual <= limit) {
    
            return;
        }

        System.gc();
        System.runFinalization();
        System.gc();
				// Calculation has several references 
        long instances = VMDebug.countInstancesOfClass(klass, false);
        if (instances > limit) {
    
            onVmPolicyViolation(new InstanceCountViolation(klass, instances, limit));
        }
    }