当我们操作完数据库后，一定要调用`close()`释放资源。 

```java
@Override  
public View getView(int position, View convertView, ViewGroup parent) {  
    ViewHolder vHolder = null;  
    //如果convertView对象为空则创建新对象，不为空则复用  
    if (convertView == null) {  
        convertView = inflater.inflate(..., null);  
        // 创建 ViewHodler 对象  
        vHolder = new ViewHolder();  
        vHolder.img= (ImageView) convertView.findViewById(...);  
        vHolder.tv= (TextView) convertView  
                .findViewById(...);  
        // 将ViewHodler保存到Tag中  
        convertView.setTag(vHolder);  
    } else {  
        //当convertView不为空时，通过getTag()得到View  
        vHolder = (ViewHolder) convertView.getTag();  
    }  
    // 给对象赋值，修改显示的值  
    vHolder.img.setImageBitmap(...);  
    vHolder.tv.setText(...);  
    return convertView;  
}  

static class ViewHolder {  
    TextView tv;  
    ImageView img;  
}  
```

`registerReceiver()`和`unregisterReceiver()`要成对出现，通常需要在`Activity`的`onDestory()`方法去取消注册广播接收者。

注意用完后及时关闭

这是一个很隐晦的`OutOfMemoryError`的情况。先看一个Android官网提供的例子： 

```java
private static Drawable sBackground;  
@Override  
protected void onCreate(Bundle state) {  
	super.onCreate(state);  
	TextView label = new TextView(this);  
	label.setText("Leaks are bad");  
	if (sBackground == null) {  
		sBackground = getDrawable(R.drawable.large_bitmap);  
	}  
	label.setBackgroundDrawable(sBackground);  
	setContentView(label);  
}  
```
这段代码效率很快，但同时又是极其错误的：    
我们看一下`setBackgroundDrawable(Drawable background)`的源码：
```java
 public void setBackgroundDrawable(Drawable background) {
	...
	background.setCallback(this);
 }
```
有`background.setCallback(this);`方法，也就是说`Drawable`拥有`TextView`的引用，而`TextView`又拥有`Activity`*(Context类型)*的引用，
因为`sBackground`为`static`的，即使`Activity`被销毁，但是`sBackground`的生命周期还没走完，所以内存仍然不会被释放。这样就会有内存泄露了。
对，这样想是对的，但是我们看一下`setCallback`的源码：
```java
  public final void setCallback(Callback cb) {
    mCallback = new WeakReference<Callback>(cb);
}
```
我们会发现里面使用了`WeakReference`，所以不会存在内存泄露了，但是官网当时提供的例子明明说有泄露，这是因为在3.0之后，
修复了这个内存泄露的问题，在3.0之前`setCallback`，方法是没有使用`WeakReference`的，所以这种泄露的情况在3.0之前会发生，3.0之后已经被修复。

线程也是造成内存泄露的一个重要的源头。线程产生内存泄露的主要原因在于线程生命周期的不可控。我们来考虑下面一段代码。
```java
public class MyActivity extends Activity {     
	@Override     
	public void onCreate(Bundle savedInstanceState) {         
		super.onCreate(savedInstanceState);         
		setContentView(R.layout.main);         
		new MyThread().start();     
	}       
	private class MyThread extends Thread{         
	@Override         
		public void run() {             
		super.run();             
		//耗时的操作       
		}     
	} 
}  
```
假设`MyThread`的`run`函数是一个很费时的操作，当调用`finish`的时候`Activity`会销毁掉吗？    
事实上由于我们的线程是`Activity`的内部类，所以`MyThread`中保存了`Activity`的一个引用，当`MyThread`的`run`函数没有结束时，`MyThread`是不会被销毁的，
因此它所引用的`Activity`也不会被销毁，因此就出现了内存泄露的问题。

**`Context`引用的生命周期超过它本身的生命周期，也会导致`Context`泄漏**。
所以如果打算保存一个长时间的对象时尽量使用`Application`这种`Context`类型。
例如: 
```java
mStorageManager = (StorageManager) getSystemService(Context.STORAGE_SERVICE);
改成：
mStorageManager = (StorageManager) getApplicationContext().getSystemService(Context.STORAGE_SERVICE);
```
按道理来说这种系统服务是不会有问题，但是有些厂商在修改的时候，可能会导致`Context`无法被及时释放。

Handler mHandler = new Handler() {
    @Override
    public void handleMessage(Message msg) {
	    // do something.
    }
}

下面看一个非静态内部类创建静态实例导致的内存泄漏
```java
public class MainActivity extends AppCompatActivity {
	private static TestResource mResource = null;
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		if(mManager == null){
			mManager = new TestResource();
		}
		//...
	}
	class TestResource {
		//...
	}
}
```
因为非静态内部类默认会持有外部类的引用，而该非静态内部类又创建了一个静态实例，该实例的声明周期与应用的一样长，
这就导致了静态实例一直会持有`Activity`的引用而造成内存泄漏。             
下面再看一个匿名内部类和异步现成的现象:        
```java
public class MainActivity extends Activity {
	...
	Runnable ref1 = new MyRunable();
	Runnable ref2 = new Runnable() {
		@Override
		public void run() {

		}
	};
	...
}
```
上面的离职中`ref1`对象是没问题的，但是`ref2`这个匿名类的实现对象中有外部类的引用，如果此时线程的生命周期与`Activity`的不一致时就会造成了泄漏。

```java
public class AppManager {
	private static AppManager instance;
	private Context context;
	private AppManager(Context context) {
		this.context = context;
	}
	public static AppManager getInstance(Context context) {
		if (instance != null) {
			instance = new AppManager(context);
		}
		return instance;
	}
}
```
这里如果传入的是`Activity`的`Context`，当该`Context`的`Activity`退出后，由于其被单例对象引用，所以会导致`Activity`无法被回收，就造成内存泄漏。