long totalMemory = Runtime.getRuntime().totalMemory();
long freeMemory = Runtime.getRuntime().freeMemory();

public class MyApplication extends BaseApplication {

    @Override
    public void onTrimMemory(int level) {
        super.onTrimMemory(level);
    }   
}

public class MyApplication extends BaseApplication {

    @Override
    public void onCreate() {
        super.onCreate();
        initLeakCanary();
    }

    private RefWatcher mRefWatcher;

    public void initLeakCanary() {
        if (LeakCanary.isInAnalyzerProcess(this)) {
            return;
        }
        mRefWatcher = LeakCanary.install(this);
    }

    public static RefWatcher getRefWatcher(Context context) {
        MyApplication application = (MyApplication) context.getApplicationContext();
        return application.mRefWatcher;
    }

}

public class MyFragment extends BaseFragment {
    @Override
    public void onDestroy() {
        super.onDestroy();
        MyApplication.getRefWatcher(getContext()).watch(this,"fragment");
    }
}

Handler mHandler = new Handler(){
     @Override
     public void handleMessage(Message msg) {
         super.handleMessage(msg);
     }
};

This Handler class should be static or leaks might occur (anonymous android.os.Handler)

Handler mHandler = new Handler();
mHandler.post(new Runnable() {
    @Override
    public void run() {
        
    }
});

new Thread(new Runnable() {
    @Override
    public void run() {
        
    }
}).start();

new AsyncTask<Void, Void, Void>() {
    @Override
    protected Void doInBackground(Void... voids) {
        return null;
    }
}.execute();

static class NoLeakHandler extends Handler {
    private WeakReference<Activity> mActivityWeakRef;
    public NoLeakHandler(Activity activity) {
        mActivityWeakRef = new WeakReference<>(activit
    }
    @Override
    public void handleMessage(Message msg) {
        super.handleMessage(msg);
        Activity activity = mActivityWeakRef.get();
        if (activity != null) {
            activity.finish();
        }
    }
}

Handler mHandler = new NoLeakHandler(this);

class NoLeakAsyncTask extends AsyncTask<Void, Void, Void> {
    private WeakReference<Activity> mActivityWeakRef;
    public NoLeakAsyncTask(Activity activity) {
        mActivityWeakRef = new WeakReference<>(activity);
    }
    @Override
    protected Void doInBackground(Void... voids) {
        return null;
    }
    @Override
    protected void onPostExecute(Void aVoid) {
        super.onPostExecute(aVoid);
        Activity activity = mActivityWeakRef.get();
        if (activity != null) {
            activity.finish();
        }
    }
}

mHandler.removeCallbacksAndMessages(null);

WeakReference<Context> mContextWeakRef;
mContextWeakRef = new WeakReference<>(getContext());

Context appContext = context.getApplicationContext();
Application application = (Application) context.getApplicationContext();

// Cursor
Cursor cursor = ...;
cursor.close();

// Stream
FileOutputStream outputStream = ...
outputStream.close();

// Bitmap
Bitmap bitmap = ...;
bitmap.recycle();

// Animation
Animation animation = ...;
animation.cancel();
animation.setAnimationListener(null);

// BroadcastReceiver
BroadcastReceiver broadcastReceiver = ...
context.unregisterReceiver(broadcastReceiver);

// byte
byte[] bytes = new byte[1024 * 8];
bytes = null;

Bitmap bitmap = null;

bitmap = Bitmap.createBitmap(100, 100, Bitmap.Config.RGB_565);

BitmapFactory.Options options = new BitmapFactory.Options();
options.inPreferredConfig = Bitmap.Config.RGB_565;
bitmap = BitmapFactory.decodeFile(filePath, options);

public Bitmap decodeFile(String filePath) {
    // 想显示的图片大小
    int reqWidth = 100;
    int reqHeight = 100;
    // 先获取图片宽高
    BitmapFactory.Options options = new BitmapFactory.Options();
    options.inJustDecodeBounds = true;
    BitmapFactory.decodeFile(filePath, options);
    int imgHeight = options.outHeight;
    int imgWidth = options.outWidth;
    // 计算 sampleSize
    int inSampleSize = 1;
    if (imgHeight > reqHeight || imgWidth > reqWidth) {
        final int halfHeight = imgHeight / 2;
        final int halfWidth = imgWidth / 2;
        // 在保证解析出的 bitmap 宽高分别大于目标尺寸宽高的前提下
        // 取可能的 inSampleSize 的最大值
        while ((halfHeight / inSampleSize) > reqHeight
                && (halfWidth / inSampleSize) > reqWidth) {
            inSampleSize *= 2;
        }
    }
    options.inSampleSize = inSampleSize;
    options.inJustDecodeBounds = false;
    return BitmapFactory.decodeFile(filePath, options);
}

private ViewModel mViewModel;

// 不应该在 get 方法中不加判断的创建对象
public ViewModel getViewModel() {
    return new ViewModel();
}

// 如果仅执行创建新对象的操作应该命名为 newXXX()
public ViewModel newViewModel() {
    return new ViewModel();
}

// 如果一定要使用 get() 方法，需要增加创建一次的判读
public ViewModel getViewModel() {
   if(mViewModel == null){
       mViewModel = new ViewModel();
   }
   return mViewModel;
}

public final class ByteArrayPool {
    private static final String TAG = "ByteArrayPool";
    private static final int TEMP_BYTES_SIZE = 64 * 1024; // 64 KB. 
    private static final int MAX_SIZE = 2 * 1048 * 1024; // 512 KB.
    private static final int MAX_BYTE_ARRAY_COUNT = MAX_SIZE / TEMP_BYTES_SIZE;
    private final Queue<byte[]> tempQueue = Util.createQueue(0);
    private static final ByteArrayPool BYTE_ARRAY_POOL = new ByteArrayPool();

    public static ByteArrayPool get() {
        return BYTE_ARRAY_POOL;
    }
    private ByteArrayPool() {  }

    public void clear() {
        synchronized (tempQueue) {
            tempQueue.clear();
        }
    }
    // 从队列中取出一个 byte[],没有就创建新的返回
    public byte[] getBytes() {
        byte[] result;
        synchronized (tempQueue) {
            result = tempQueue.poll();
        }
        if (result == null) {
            result = new byte[TEMP_BYTES_SIZE];
            if (Log.isLoggable(TAG, Log.DEBUG)) {
                Log.d(TAG, "Created temp bytes");
            }
        }
        return result;
    }
    // 使用完了放回队列，但是要维持总内存不超过 max
    public boolean releaseBytes(byte[] bytes) {
        if (bytes.length != TEMP_BYTES_SIZE) {
            return false;
        }
        boolean accepted = false;
        synchronized (tempQueue) {
            if (tempQueue.size() < MAX_BYTE_ARRAY_COUNT) {
                accepted = true;
                tempQueue.offer(bytes);
            }
        }
        return accepted;
    }
}