四种引用分别为： 强引用（StrongRefernce）、软引用（SoftReference） 、弱引用（WeakReference） 、虚引用（PhantomReference）

1. 强引用（StrongRefernce）

四种引用中，强引用是我们使用的最多的一种引用对象，对强应用的使用，在编码过程中也是无处不在，例如创建一个成员变量，new 出一个对象等等……；

强引用可以直接访问目标对象，强引用所关联的对象，在任何时候都不会被内存回收，JVM宁肯抛出OOM异常，也不会对其进行回收，所以，在通常的内存泄漏中，大多都有强引用的身影。

例如：

String s1=new String("");

String s2=s1;

2. 软引用（SoftReference）

软引用是除了强引用外，最强的引用类型。可以通过java.lang.ref.SoftReference使用软引用。一个持有软引用的对象，不会被JVM很快回收，JVM会根据当前堆的使用情况来判断何时回收。当堆的使用率临近阈值时，才会回收软引用的对象。

import java.lang.ref.SoftReference;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;
import android.graphics.drawable.Drawable;
import android.os.Handler;
import android.os.Message;
//实现图片异步加载的类
public class AsyncImageLoader
{
  //以Url为键，SoftReference为值，建立缓存HashMap键值对。
  private Map<String, SoftReference<Drawable>> mImageCache =
    new HashMap<String, SoftReference<Drawable>>();
//实现图片异步加载
  public Drawable loadDrawable(final String imageUrl, final ImageCallback callback)
  {
    //查询缓存，查看当前需要下载的图片是否在缓存中
    if(mImageCache.containsKey(imageUrl))
    {
      SoftReference<Drawable> softReference = mImageCache.get(imageUrl);
      if (softReference.get() != null)
      {
        return softReference.get();
      }
    }
    final Handler handler = new Handler()
    {
      @Override
      public void dispatchMessage(Message msg)
      {
        //回调ImageCallbackImpl中的imageLoad方法，在主线(UI线程)中执行。
        callback.imageLoad((Drawable)msg.obj);
      }
    };
    /*若缓存中没有，新开辟一个线程，用于进行从网络上下载图片，
     * 然后将获取到的Drawable发送到Handler中处理，通过回调实现在UI线程中显示获取的图片
     */
    new Thread()
    {  
      public void run()
      {
        Drawable drawable = loadImageFromUrl(imageUrl);
        //将得到的图片存放到缓存中
        mImageCache.put(imageUrl, new SoftReference<Drawable>(drawable));
        Message message = handler.obtainMessage(0, drawable);
        handler.sendMessage(message);
      };
    }.start();
    //若缓存中不存在，将从网上下载显示完成后，此处返回null；
    return null;
  }
  //定义一个回调接口
  public interface ImageCallback
  {
    void imageLoad(Drawable drawable);
  }
  //通过Url从网上获取图片Drawable对象；
  protected Drawable loadImageFromUrl(String imageUrl)
  {
      try
      {
      return Drawable.createFromStream(new URL(imageUrl).openStream(),"debug");
      } catch (Exception e) {
      // TODO: handle exception
      throw new RuntimeException(e);
    }

  }

}

3. 弱引用（WeakReference）

只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它 所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程， 因此不一定会很快发现那些只具有弱引用的对象。

Activity具有自身的生命周期，Activity中新开启的线程运行过程中，可能此时用户按下了Back键，或系统内存不足等希望回收此Activity，由于Activity中新起的线程并不会遵循Activity本身的什么周期，也就是说，当Activity执行了onDestroy,由于线程以及Handler 的HandleMessage的存在，使得系统本希望进行此Activity内存回收不能实现，因为非静态内部类中隐性的持有对外部类的引用，导致可能存在的内存泄露问题。

因此，在Activity中使用Handler时，一方面需要将其定义为静态内部类形式，这样可以使其与外部类（Activity）解耦，不再持有外部类的引用，同时由于Handler中的handlerMessage一般都会多少需要访问或修改Activity的属性，此时，需要在Handler内部定义指向此Activity的WeakReference，使其不会影响到Activity的内存回收同时，可以在正常情况下访问到Activity的属性。

例如：

public class MainActivity extends Activity {
    private int page;
    private MyHandler mMyHandler = new MyHandler(this);
    private static class MyHandler extends Handler {
        private WeakReference<MainActivity> wrActivity;
        public MyHandler(MainActivity activity) {
            this.wrActivity = new WeakReference<MainActivity>(activity);
        }

        @Override
        public void handleMessage(Message msg) {
            if (wrActivity.get() == null) {
                return;
            }
            MainActivity mActivity = wrActivity.get();
            if (msg.what == 1) {
                //...
                mActivity.page++;
            } else {
                //...
            }
        }
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //...
        new Thread(new Runnable() {
            @Override
            public void run() {
                //..
                Message msg = Message.obtain();
                msg.what = 1;
                //msg.obj = xx;
                mMyHandler.sendMessage(msg);
            }
        }).start();
        //...
    }
}

4. 虚引用（PhantomReference）

虚引用不能保证其保存对象生命周期，其保存对象若只有虚引用，则其有效期完全随机于GC的回收，在任何一个不确定的时间内，都可能会被回收；而虚引用与其他几者的引用不同在于，在使用PhantomReference，必须要和Reference联合使用。

对比：

SoftReference soft = new SoftReference<>(new Object());

WeakReference<Object> weak = new WeakReference<>(new Object());

WeakReference<String> weakString = new WeakReference<>("abc");

PhantomReference<Object> phantom = newPhantomReference<>(new Object(),newReferenceQueue<>());

System.gc();System.out.println(soft.get());  

System.out.println(weak.get()); 

System.out.println(weakString.get());

System.out.println(phantom.get());

soft类型由于内存还充足，不会被回收；weak类型在gc的时候就回收；phantom总是返回null。weakString没被回收是引用常量池持有对"abc"的引用。