单例的N种写法

2017-12-18

public class Singleton1 {
    private static Singleton1 singleton = null;
    private Singleton1() {}
    public static Singleton1 newInstance() {
        if(singleton == null) {
            singleton = new Singleton1();
        }
        return singleton;
    }
}

优点：惰性加载
缺点：多线程有问题

public class Singleton2 {
    private static Singleton2 singleton = null;
    private Singleton2() {}
    public synchonized static Singleton2 newInstance() {
        if(singleton == null) {
            return new Singleton2();
        }
        return singleton;
    }
}

优点：多线程问题解决
缺点：newInstance 阻塞

public class Singleton3 {
    private static Singleton3 singleton = null;
    privte Singleton3() {}
    public static Singleton3 newInstance() {
        if(singleton == null) {
            synchonized(this.class) {
                if(singleton == null) {
                    return new Singleton3();
                }
            }
        }
        return singleton;
    }
}

优点：性能提升，不会再newInstance阻塞。
缺点：线程安全有问题，new Singleton3()在指令重排序的情况下，可能只生成了半个对象。
详解

public class Singleton4 {
    private static volatile Singleton4 singleton = null;
    private Singleton4() {}
    public Singleton4 newInstance() {
        if(singleton == null) {
            sychonized(this.class) {
                if(singleton == null) {
                    return new Singleton4();
                }
            }
        }
        return singleton;
    }
}

优点：线程安全解决，性能可行，推荐
缺点：写起来麻烦。

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

优点：写起来简单，线程安全（classload）机制保证。
缺点：在Singleton5被加载时实例就已经被初始化了。

private static Singleton5 singleton = null;
static {
    singleton = new Singleton5();
}

同理

1
2
3

public enum Singleton6 {
    SINGLETON;
}

优点：写法简单清晰，线程安全，effective java隆重推荐，不会因为序列化和反序列话新增对象
缺点：不能实现懒加载

public class Singleton7 {
    private static class SingletonHolder() {
        private static final Singleton7 singleton = new Singleton7();
        private SingletonHolder() {}
    }
    private Singleton7() {}
    public Singleton7 newInstance() {
        return SingletonHolder.singleton;
    }
}

优点：间接实现了懒加载，因为在singleton加载的时候，SingletonHolder并不会被实例化。

实现方式	关键点	资源浪费	线程安全	多线程环境的性能足够优化
基础饱汉	懒加载	否	否	-
饱汉变种1	懒加载、同步	否	是	否
饱汉变种2	懒加载、DCL	否	否	-
饱汉变种3	懒加载、DCL、volatile	否	是	是
饿汉	静态变量初始化	是	是	是
Holder	静态变量初始化、holder	否	是	是
枚举	枚举本质、静态变量初始化	否	是	是

参考

单例模式有几种写法

如果单例由不同的类装载器装入，那便有可能存在多个单例类的实例。假定不是远端存取，例如一些servlet容器对每个servlet使用完全不同的类装载器，这样的话如果有两个servlet访问一个单例类，它们就都会有各自的实例。

private static Class getClass(String classname) throws ClassNotFoundException {     
      ClassLoader classLoader = Thread.currentThread().getContextClassLoader();     
      if(classLoader == null)     
         classLoader = Singleton.class.getClassLoader();     
      return (classLoader.loadClass(classname));     
   }     
}

如果Singleton实现了java.io.Serializable接口，那么这个类的实例就可能被序列化和复原。不管怎样，如果你序列化一个单例类的对象，接下来复原多个那个对象，那你就会有多个单例类的实例。

public class Singleton implements java.io.Serializable {     
   public static Singleton INSTANCE = new Singleton();     
   protected Singleton() {     
   }     
   private Object readResolve() {     
            return INSTANCE;     
      }    
}