话题：Java基础知识学习

1、Java中有哪几种引用？它们的含义和区别是什么？
2、请用Java实现一个线程安全且高效的单例模式。

Java中有哪几种引用？它们的含义和区别是什么？

在JDK1.2 之前,java中引用的定义：如果引用类型的数据类型中存储的数值代表的是一块内存的起始地址，就称这块内存代表一个引用，在JDK1.2 之后，java把引用类型分为四种级别，这四种级别由高到低分别是：强引用，软引用，弱引用和虚引用

• 强引用（StrongReference）
  当内存空间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足的问题，因此强引用是造成Java内存泄露的主要原因之一。
  其实就是我们平时的
  String[] arr = new String[]{"a", "b", "c"};
• 软引用（SoftReference）
  如果一个对象只具有软引用，则内存空间足够，垃圾回收器就不会回收它；如果内存空间不足了，就会回收这些对象。只要垃圾回收器没有回收它，该对象就可以被程序使用。软引用可以用来实现内存敏感的高速缓存
  软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被垃圾回收器回收，java虚拟机就会把这个软引用加入到与之关联的队列引用中。

SoftReference<String[]> softBean = new SoftReference<String[]>(new String[]{"a", "b", "c"});

• 弱引用（WeakReference）
  只具有弱引用的对象拥有短暂的生命周期，在垃圾回收器线程扫描它所管辖的内存区域中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存，不过由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象
  弱引用可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被垃圾回收，java虚拟机就会把这个弱引用加入到与之关联的引用队列中

WeakReference<String[]> weakBean = new WeakReference<String[]>(new String[]{"a", "b", "c"});

• 虚引用（PhantomReference）
  顾名思义：形同虚设，虚引用并不会决定对象的什么周期，如果一个对象仅只有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。程序也并不能通过虚引用访问被引用的对象。
  虚引用主要用来跟踪垃圾回收器回收的活动，虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列（ReferenceQueue）联合使用，当垃圾准备回收一个对象时，如果发现它还有虚引用，就会在回收对象内存之前，把这个虚引用加入到与之关联的队列中

ReferenceQueue<String[]> referenceQueue = new ReferenceQueue<String[]>();
PhantomReference<String[]> referent = new PhantomReference<String>(new String[]{"a", "b", "c"}, referenceQueue);

表格对比

类型	强引用	软引用	弱引用	虚引用
引用级别	最高	较高	较低	无
回收级别	不回收	较难回收	较易回收	容易回收
能否被JVM回收	不能	垃圾回收器工作并且内存不足条件下能回收	只要垃圾回收器工作就会回收	只要垃圾回收器工作就会回收
取得目标对象方式	直接调用	通过get()方法	通过get()方法	无法取得
用途	常住内存最高	内存敏感时代替强引用，常用于实现内存敏感的高速缓存	适用于存储元数据，如WeakHashMap(map 中的键值都被封装成了弱引用，一旦强引用被删除，WeakHashMap就无法阻止该对象被垃圾回收器回收)	跟踪对象被垃圾回收的状态
是否可能内存泄露	可能	不可能	不可能	可能
比如 (面向对象的现实场景)	家里的必须生活用品，你不会扔掉	家里可有可无的生活用品，家里有空间的时候你会保留，家里没空间的时候你就会扔掉	家里没什么用的东西，比如生活垃圾，不管家里有没有空间，你都不想放到家里，随时都想把他扔掉	你想知道那些必要的东西是否还保留着，于是你借用了一个储物柜（按照顺序存放），可以看到那些东西你扔掉了，那些东西你没扔掉

来源：
Java中的四种引用类型
Java内存回收机制--Java引用的种类（强引用、弱引用、软引用、虚引用）

单例模式几种方法

恶汉式

public class Singleton {
    private  static Singleton singleton=new Singleton();
    private Singleton(){}
    public static Singleton newInstance(){
        return singleton;
    }
}

双重校验锁 DCL

public class Singleton {
    private  static volatile Singleton singleton;
    private Singleton(){}
    public static Singleton newInstance(){
        if(singleton==null){
            synchronized (Singleton.class){
                if(singleton==null){
                    singleton=new Singleton();
                }
            }
        }
        return singleton;
    }
}

volatile的两层含义:

• 可见性。可见性指的是在一个线程中对该变量的修改会马上由工作内存（Work Memory）写回主内存（Main Memory），所以会马上反应在其它线程的读取操作中
• 禁止指令重排优化，但是这个语义直到jdk1.5以后才能正确工作。此前的JDK中即使将变量声明为volatile也无法完全避免重排序所导致的问题。所以，在jdk1.5版本前，双重检查锁形式的单例模式是无法保证线程安全的。不过好在现在使用JDK1.5 之前版本的很少很少了，

静态内部类

public class Singleton {
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }
    private Singleton() {
    }
    public static final Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

以上所有实现方式都有两个共同缺点：

• 都需要额外的工作(Serializable、transient、readResolve())来实现序列化，否则每次反序列化一个序列化的对象实例时都会创建一个新的实例。
• 可能会有人使用反射强行调用我们的私有构造器（如果要避免这种情况，可以修改构造器，让它在创建第二个实例的时候抛异常）。

枚举写法

public enum Singleton {
    INSTANCE;
}

使用枚举除了线程安全和防止反射强行调用构造器之外，还提供了自动序列化机制，防止反序列化的时候创建新的对象。因此，Effective Java推荐尽可能地使用枚举来实现单例。尽管枚举写法有点这么多，但是在Android平台上却不被推荐，原因 Android 官方API指南 明确指出：Enums often require more than twice as much memory as static constants. You should strictly avoid using enums on Android. 翻译过来就是枚举通常需要比静态常量多两倍的内存。 你应该严格避免在Android上使用枚举。简单来说就是枚举耗内存，而Android最缺的就是内存。

参考链接： 你真的会写单例模式吗——Java实现

下面是我在Android源码中看到的，看着像是懒汉式的二次封装，可以参考一下

懒汉式的二次封装

//android.util.Singleton.java
public abstract class Singleton<T> {
    private T mInstance;
    protected abstract T create();
    public final T get() {
        synchronized (this) {
            if (mInstance == null) {
                mInstance = create();
            }
            return mInstance;
        }
    }
}

//使用方法如下
public abstract class ActivityManagerNative extends Binder implements IActivityManager {
    private static final Singleton<IActivityManager> gDefault = new Singleton<IActivityManager>() {
        protected IActivityManager create() {
            IBinder b = ServiceManager.getService("activity");//通过应用程序中的0号引用，可以向SMgr获取服务端（Server）的Binder引用。
            IActivityManager am = asInterface(b);
            return am;
        }
    };

static public IActivityManager getDefault() {
        return gDefault.get();
    }
}
//////////
ActivityManagerNative.getDefault().finishActivityAffinity(mToken)

请用Java实现一个线程安全且高效的单例模式。

如果是在Android应用上，建议使用双重校验锁 DCL 或者静态内部类，这两个效果是一样的。
如果是java程序，建议使用 枚举类型写法