单例模式

单例模式是比较常见的设计模式。

是一种常用的软件设计模式，在它的核心结构中值包含一个被称为单例的特殊类。一个类只有一个实例，即一个类只有一个对象实例。

单例模式的优点

　　我们从单例模式的定义和实现，可以知道单例模式具有以下几个优点：

• 在内存中只有一个对象，节省内存空间；

• 避免频繁的创建销毁对象，可以提高性能；

• 避免对共享资源的多重占用，简化访问；

• 为整个系统提供一个全局访问点。

• 有状态的工具类对象；
• 频繁访问数据库或文件的对象；

单例模式的使用场景

　　由于单例模式具有以上优点，并且形式上比较简单，所以是日常开发中用的比较多的一种设计模式，其核心在于为整个系统提供一个唯一的实例，其应用场景包括但不仅限于以下几种：

• 有状态的工具类对象；
• 频繁访问数据库或文件的对象；

1.第一种（懒汉式）：

public class Singleton{

    public static Singleton sInstance = null;
    //构造函数声明为private，是阻止外部实例化这个类。因为默认无参数构造方法是public的。

    private Singleton(){
    }

    public static Singleton getInstance(){

    if  (sInstance == null ) {

             sInstance = new Singleton();
        }

        return sInstatce;

    }

    private void getValue(){

        System.out.println("this is the easy singleton!");

    }

}

在其他类里使用：

Singleton  mSingleton = Singleton.getInstance();

mSingleton.getValue();

这个写法缺点：

特点：延迟加载，需要的时候才使用。 

缺点：单线程使用是没问题的，但是我们的web开发都是需要并发的，所以这个代码适用场景较小,线程不安全

第二种（懒汉式）

public class Singleton1 {

    public static Singleton1 sInstance = null;

    public Singleton1 () {

   }

   public static Synchronized Singleton1 getInstance () {

        if (sInstance == null) {

            sInstance = new Singleton1();

         }

         return sInstance;

    }

}

这种写法在getInstance()方法中加入了synchronized锁。能够在多线程中很好的工作，而且看起来它也具备很好的lazy loading(延迟加载)，但是效率很低（因为锁），并且大多数情况下不需要同步。

第三种 （饿汉式）:

public class Singleton3{

    public static Singleton3 sInstance = new Singleton3();

    private Singleton3() {

         //构造函数声明为private，是阻止外部实例化这个类。因为默认无参数构造方法是public的。

    }

    public static Singleton3 getInstance() {

        return sInstance;

    }

}

这种方式基于classloder机制避免了多线程的同步问题，不过，instance在类装载时就实例化，这时候初始化instance显然没有达到lazy loading的效果

2.第四种（恶汉式，）：

public class Singleton1{

    public static Singleton1 sInstance = null;

    static {

     //在构造函数前就进行实例化

        sInstance = new Singleton1();

    }

    private Singleton1() {

         //构造函数声明为private，是阻止外部实例化这个类。因为默认无参数构造方法是public的。

    }

    public static Singleton1 getInstance() {

        return sInstance;

    }

}

都是在类初始化中即实例化sInstance.

优点：线程安全 

缺点：不是延迟加载的，当构造这样的单例非常重量级，但是这个单例可能很久也用不到一次的时候比较受伤。（这样的场景比较少）(意思是占用内存)

第五种（静态内部类）：

public class Singleton5{

    public static class SingletonHolder(){

        private static sInstance = null;

        static {

            sInstance = new Singleton5();

        }

    }

    public Singleton5(){

        //构造函数声明为private，是阻止外部实例化这个类。因为默认无参数构造方法是public的。

    }

    public static Singleton5 getInstance() {

        return SingletonHolder.sInstance;

    }

    public static final void main (String[] args) {  

        System.out.prinln("do anything");

    }

}

这种方式同样利用了classloder的机制来保证初始化instance时只有一个线程，它跟第三种和第四种方式不同的是（很细微的差别）：第三种和第四种方式是只要Singleton类被装载了，那么instance就会被实例化（没有达到lazy loading效果），而这种方式是Singleton类被装载了，instance不一定被初始化。因为SingletonHolder类没有被主动使用，只有显示通过调用getInstance方法时，才会显示装载SingletonHolder类，从而实例化instance。想象一下，如果实例化instance很消耗资源，我想让他延迟加载，另外一方面，我不希望在Singleton类加载时就实例化，因为我不能确保Singleton类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化instance显然是不合适的。这个时候，这种方式相比第三和第四种方法就显得更合理。

第六种（枚举）：

enum Singleton6{

      sInstance;

      public void getInstatnce() {

         System.out.println("something");

     } 

}

它不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。如果用枚举去实现一个单例，这样的加载有点类似于饿汉模式.

1.线程安全； 
2.不会因为序列化而产生新的实例(因为它自己实现了readResolve方法)； 

3.防止反射攻击。(因为enum实际上是abstract的)

第七种(double check locked)

public class Singleton7 {

    public static volatile Singleton7 sInstance = null;
    public Singleton7 () {

   }
   public static Singleton7 getInstance () {
        if (sInstance == null) { 
            Synchronized(Singleton7.class){
                if (sInstance == null) {
                    sInstance = new Singleton7();          
                }       
            }
         }
         return sInstance;
    }
}

双重检查锁定（DCL），若没有volatile 修饰，有因为内存模型的问题，会存在指令重排的问题。

增加了volatile修饰后：

1.禁止指令重排序 
2.内存可见性 
规则1可以确保外层null检查要么看到的是null，要么看到的是一个构造完整的对象，规则2可以解决之前浪费的问题。

问题点1：

单例模式唯一实现为什么必须要静态？

单例模式实现过程：

1.构造方法进行私有化修饰，防止直接被创建实例

2. 在本类中自定义一个对象（既然禁止其他程序创建该类的对象，就要自己创建一个供程序使用，否则类就没法用，更不是单例）

3. 提供一个可访问类自定义对象的类成员方法（对外提供该对象的访问方式）。

这就是说其他地方使用该类创建对象，那就在类里面创建方法来访问自定义的对象。

访问类中的方法有两种方式：1.创建类对象，用对象来访问类中的方法 2. 直接使用类来访问，如类名.方法名()；

但是在单例模式下，因为不能创建类的对象， 所以只能用类来访问。 用类访问就要用static 来修饰，同时因为静态方法不能访问非静态成员变量，所以自定义的实例变量也是static的。

这就是单例模式唯一实现必须要静态的原因。

问题点2：

枚举为什么可以实现反序列化？

因为在enum 类中实现了readObject, 并私有化，无法对枚举进行反序列化

public abstract class Enum<E extends Enum<E>>
        implements Comparable<E>, Serializable {

····
 /**
     * prevent default deserialization
     */
    private void readObject(ObjectInputStream in) throws IOException,
        ClassNotFoundException {
        throw new InvalidObjectException("can't deserialize enum");
    }

    private void readObjectNoData() throws ObjectStreamException {
        throw new InvalidObjectException("can't deserialize enum");
    }
}

一般情况下，单例类实现了序列化接口，readObject会一直返回新的对象，会破坏单例，所以可以在类中实现如下方法：

//readResolve to prevent another instance of Singleton
    private Object readResolve(){
        return INSTANCE;
    }

问题3:

为什么枚举单例可以线程安全？

根据反编译枚举单例的代码来看，创建对象是在静态代码块中实现，静态代码快会在类创建初始化时就执行，可以保证安全.