单例模式

解释：确保一个类在任何情况下绝对只有一个实例，并提供一个全局访问点。

例如：ApplicationContext、ServletContext。。。。。

特点：隐藏构造方法。提供公共获取实例的方法。

1、饿汉式单例

不管用不用直接初始化，浪费内存空间。但是是线程安全的。

package com.ldy.designpattern.simpleFactory.singlePattern;

public class HungrySingleton {

    private HungrySingleton(){}

    //final修饰之后防止其他此实例被覆盖
    private static final HungrySingleton hungrySingleton=new HungrySingleton();

    public static HungrySingleton getInstance(){
        return hungrySingleton;
    }
}

2、懒汉式单例

在外部调用的时候才初始化对象。一开始并不初始化，比饿汉式更灵活点。

package com.ldy.designpattern.simpleFactory.singlePattern;

public class LazyPattern {
    private LazyPattern(){}//私有化构造函数

    private static LazyPattern lazyPattern = null;

    public synchronized static LazyPattern getLazyPattern(){
        if(lazyPattern == null){//如果不为空，直接返回原实例。为空则新创建实例再返回
            lazyPattern=new LazyPattern();
        }
        return lazyPattern;
    }
}

3、双重锁懒汉式单例

懒汉式单例中，使用synchronized关键字来保护多线程下的安全。但是此时的锁是类锁(因为static修饰)，此锁作用时整个类都不能与其他线程共享。于是就有了DoubleCheck方案。

package com.ldy.designpattern.simpleFactory.singlePattern;

public class DoubleChackLazySingleton {
    private static DoubleChackLazySingleton doubleChackLazySingleton = null;

    public static DoubleChackLazySingleton getLazyPattern(){
        if(doubleChackLazySingleton == null){//如果不为空，直接返回原实例。为空则新创建实例再返回
            synchronized (DoubleChackLazySingleton.class){
                if(doubleChackLazySingleton == null) {
                    doubleChackLazySingleton = new DoubleChackLazySingleton();
                }
            }
        }
        return doubleChackLazySingleton;
    }
}

4、静态内部类单例（别人说最牛*的写法）

同样是懒汉式写法。

package com.ldy.designpattern.simpleFactory.singlePattern;

/**使用内部类来完成单例
 * 初始化过程没有synchronized关键字，性能很好
 * 使用的是jvm的类加载机制来保障初始化的安全
 */
public class InnerClassSingleton {

    private InnerClassSingleton(){}

    public static final InnerClassSingleton getInstance(){
        return LazySingletonInner.innerClassSingleton;
    }

    private static class LazySingletonInner{
        private static final InnerClassSingleton innerClassSingleton = new InnerClassSingleton();
    }
}

5、枚举式单例

 使用枚举来实现单例是非常安全的，也是官方推荐的一种方式。因为jvm中无论是反射还是序列化都对枚举实现单例进行了保护。

5.1、枚举实现单例

首先枚举类如下：我希望类中的Apple apple对象是单例的。

public enum EnumSingleton {
    FRUIT;
    private Apple apple=new Apple();
    private EnumSingleton(){ }

    public static void main(String[] args) {
        Apple a=EnumSingleton.FRUIT.apple;
        Apple a1=EnumSingleton.FRUIT.apple;
        System.out.println(a);
        System.out.println(a1);
        System.out.println(a==a1);
    }
}

结果如下：使用枚举类调用apple，产生的对象始终是同一个。Apple的构造方法也只被调用了一次。

 

 5.2、使用反射破解单例。调整main()函数如下：

    public static void main(String[] args) {
        try{
            Class c=EnumSingleton.class;
            Constructor declaredConstructor = 
                    c.getDeclaredConstructor(String.class,int.class);
            declaredConstructor.setAccessible(true);
            declaredConstructor.newInstance();
//            Apple a1= o.apple;
//            Apple a=EnumSingleton.FRUIT.apple;
//            System.out.println(o);
//            System.out.println(a1);
            }catch (Exception e){
            e.printStackTrace();
            }
    }

结果显示不能通过反射创建enum对象。。。。。。这个需要反编译才能搞明白，我今天只想理解这个模式，就不深入了。

可以参考这位朋友的https://www.cnblogs.com/kailejun/p/6624471.html

5.3、序列化能否破坏枚举单例

序列化源码ObjectInputStream.java中这样写： 

Enum<?> en = Enum.valueOf((Class)cl, name);返回的对象是用Class全限定名和枚举中的名字决定的，Class在jvm中肯定是独一份的，枚举中的名字也是不可重复的。二者决定的对象也是单例的。

 6、注册式单例（容器式单例）

类似于向spring容器中注册bean，IOC容器中的bean实例都是单例的。

package com.ldy.designpattern.simpleFactory.singlePattern;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ContainerSingleton {

   private Map<String,Object> beanMap = new ConcurrentHashMap<>();//将所有的单例保存在此容器中

    //获取容器中的bean
    //如果没有则进行注册，
    //懒汉式单例模式
   public Object getBean(String beanName){
       try {
           if(!beanMap.containsKey(beanName)) {
               synchronized (this) {
                   if (!beanMap.containsKey(beanName)) {
                       Object object = Class.forName(beanName).newInstance();
                       beanMap.put(beanName, object);
                       return object;
                   }
               }
           }
       }catch (Exception e){
           e.printStackTrace();
       }
       return beanMap.get(beanName);
   }

    public static void main(String[] args) {
       long start=System.currentTimeMillis();
        ContainerSingleton containerSingleton =new ContainerSingleton();
        //启用1000个线程同时访问，看看取得对象是不是同一个
        ExecutorService executorService = Executors.newFixedThreadPool(1000);
        for(int i=0;i<1000;i++){
            executorService.submit(new Thread(new Runnable() {
                @Override
                public void run() {
                    Object bean = containerSingleton.getBean(
                            "com.ldy.designpattern.simpleFactory.Apple");
                    System.out.println(bean);
                }
            }));
        }
        executorService.shutdown();
        long time=System.currentTimeMillis()-start;
        System.out.println("共耗时->"+time);
    }
}

结果确实取出的对象是同一个。

7、破坏单例

 7.1、利用反射调用构造函数生产出新的对象。

    public static void main(String[] args) throws Exception {
        Class c= InnerClassSingleton.class;
        Constructor constructor = c.getDeclaredConstructor(null);
//        constructor.setAccessible(true);//强制访问
        Object o = constructor.newInstance();

        Object o1 = InnerClassSingleton.getInstance();
        System.out.println(o==o1);//结果为false，说明二者不是同一个对象，则破坏了单例模式

    }

解决方案也比较简单：

在构造方法中加一次判断，如果要返回的实例不为空，则抛出异常不允许创建实例。或者狠心点直接抛出异常。

public class InnerClassSingleton {

    private InnerClassSingleton() {//私有化的构造方法
            throw new RuntimeException("此类为单例模式，请使用getInstance()方法");
    }
}

 7.2、序列化

 将单例对象经过序列化与反序列化出来的对象与调用getInstance()返回的对象是不一样的。

是因为反序列化中会使用反射新生成出来一个对象。

此时反序列化已经使用反射为单例实例化了一个对象。但是jvm为了保护单例，又在该方法中增加了以下的判断：判断原类中是否含有readResolve()方法。如果这个方法，反序列化就使用此方法返回的对象，如果没有此方法则返回反射生成的对象。

反序列化实际上先经过反射创建了一个对象，后面使用我们的readResolve()方法又有一个新对象，就产生了两个对象，只不过前一个GC被回收了。

所以为了不让反序列化破坏单例，需要在原类中重写readResolve()方法。

    private Object readResolve(){
        return LazySingletonInner.innerClassSingleton;
    }