一篇博客读懂设计模式之---单例模式

一。单例模式

单例对象（Singleton）是一种常用的设计模式。在Java应用中，单例对象能保证在一个JVM中，该对象只有一个实例存在。这样的模式有几个好处：

1、某些类创建比较频繁，对于一些大型的对象，这是一笔很大的系统开销。

2、省去了new操作符，降低了系统内存的使用频率，减轻GC压力。

3、有些类如交易所的核心交易引擎，控制着交易流程，如果该类可以创建多个的话，系统完全乱了。所以只有使用单例模式，才能保证核心交易服务器独立控制整个流程。

总体来说，单例模式应用的场景一般发现在以下条件下：

　　（1）资源共享的情况下，避免由于资源操作时导致的性能或损耗等。如日志文件，应用配置。

　　（2）控制资源的情况下，方便资源之间的互相通信。如线程池等。

有以下的特点：（eg。每台计算机可以有若干通信端口，系统应当集中管理这些通信端口，以避免一个通信端口同时被两个请求同时调用。为了避免不一致状态）

1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。

3、单例类必须给所有其他对象提供这一实例。

优缺点

优点：（频繁new同一个）
    1.在单例模式中，活动的单例只有一个实例，对单例类的所有实例化得到的都是相同的一个实例。这样就防止其它对象对自己的实例化，确保所有的对象都访问一个实例
    2.单例模式具有一定的伸缩性，类自己来控制实例化进程，类就在改变实例化进程上有相应的伸缩性。
    3.提供了对唯一实例的受控访问。
    4.由于在系统内存中只存在一个对象，因此可以节约系统资源，当需要频繁创建和销毁的对象时单例模式无疑可以提高系统的性能。
    5.允许可变数目的实例。

6.避免对共享资源的多重占用。

缺点：（保存状态，扩展职责）
    1.不适用于变化的对象，如果同一类型的对象总是要在不同的用例场景发生变化，单例就会引起数据的错误，不能保存彼此的状态。
    2.由于单例模式中没有抽象层，因此单例类的扩展有很大的困难。
    3.单例类的职责过重，在一定程度上违背了“单一职责原则”。

4.滥用单例将带来一些负面问题，如为了节省资源将数据库连接池对象设计为的单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出；如果实例化的对象长时间不被利用，系统会认为是垃圾而被回收，这将导致对象状态的丢失。

1）*懒汉式单例：Singleton通过将构造方法限定为private避免了类在外部被实例化，在同一个虚拟机范围内，Singleton的唯一实例只能通过getInstance()方法访问。
ps：以上懒汉式单例的实现没有考虑线程安全问题，它是线程不安全的，并发环境下很可能出现多个Singleton实例，要实现线程安全，有以下三种方式，都是对getInstance这个方法改造，保证了懒汉式单例的线程安全，

//懒汉式单例类.在第一次调用的时候实例化自己
public class Singleton1 {//1、第一步先将构造方法私有化private Singleton1(){}//2、然后声明一个静态变量保存单例的引用private static Singleton1 single = null;//3、通过提供一个静态方法来获得单例的引用//不安全的public static Singleton1 getInstance(){if (single == null){single = new Singleton1();}return  single;}
}

//懒汉式单例.保证线程安全
public class Singleton2 {//1、第一步先将构造方法私有化private Singleton2(){}//2、然后声明一个静态变量保存单例的引用private static Singleton2 single = null;//3、通过提供一个静态方法来获得单例的引用//为了保证多线程环境下正确访问，给方法加上同步锁synchronized//慎用  synchronized 关键字，阻塞，性能非常低下的//加上synchronized关键字以后，对于getInstance()方法来说，它始终单线程来访问//没有充分利用上我们的计算机资源，造成资源的浪费public static synchronized Singleton2 getInstance(){if(single == null){single = new Singleton2();}return single;}
}

//懒汉式单例.双重锁检查
public class Singleton3 {//1、第一步先将构造方法私有化private Singleton3(){}//2、然后声明一个静态变量保存单例的引用private static Singleton3 single = null;//3、通过提供一个静态方法来获得单例的引用//为了保证多线程环境下的另一种实现方式，双重锁检查//性能，第一次的时候public static Singleton3 getInstance(){synchronized (Singleton3.class){if (single == null){single = new Singleton3();}return single;}}
}

2）*饿汉式单例：（饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以天生是线程安全的。）


public class Singleton4 {/*** 懒汉式单例* 最常用的一种模式就是这种*///1. 私有化构造器//相当于有一个默认的public的无参的构造方法，就意味着在代码中随时都可以new出来private Singleton4(){}//2. 生成一个静态内部构造类//private 私有的保证别人不能修改//static 保证全局唯一private static class LazyLoader{//final 为了防止内部误操作，代理模式，GgLib的代理模式//静态内部类是为了防止反射获取属性private static final Singleton4 INSTANCE = new Singleton4();}//3、同样提供静态方法获取实例//final 确保别人不能覆盖public static Singleton4 getInstance(){//【静态方法】中的逻辑，是要在用户调用的时候才开始执行的//方法中实现逻辑需要分配内存，也是调用时才分配的//【区别】与静态块的最大区别return LazyLoader.INSTANCE;}
}

还有一种注册式：


//类似Spring里面的方法，将类名注册，下次从里面直接获取。
public class Singleton5 {private static Map<String,Singleton5> map = new HashMap<>();static {Singleton5 single = new Singleton5();map.put(single.getClass().getName(), single);}//静态工厂方法,返还此类惟一的实例private Singleton5(){}public static Singleton5 getInstance(String name) throws ClassNotFoundException {if(name == null){name = Singleton5.class.getName();}if(map.get(name) == null){try{map.put(name,(Singleton5)Class.forName(name).newInstance());} catch (IllegalAccessException e) {e.printStackTrace();} catch (InstantiationException e) {e.printStackTrace();}}return map.get(name);}
}

3）饿汉式和懒汉式区别（重点）

从名字上来说，饿汉和懒汉，

饿汉就是类一旦加载，就把单例初始化完成，保证getInstance的时候，单例是已经存在的了，

而懒汉比较懒，只有当调用getInstance的时候，才回去初始化这个单例。

另外从以下两点再区分以下这两种方式：

1、线程安全：

饿汉式天生就是线程安全的，可以直接用于多线程而不会出现问题，

懒汉式本身是非线程安全的，为了实现线程安全有几种写法，分别是下面的1、2、3，这三种实现在资源加载和性能方面有些区别。

2、资源加载和性能：

饿汉式在类创建的同时就实例化一个静态对象出来，不管之后会不会使用这个单例，都会占据一定的内存，但是相应的，在第一次调用时速度也会更快，因为其资源已经初始化完成，

而懒汉式顾名思义，会延迟加载，在第一次使用该单例的时候才会实例化对象出来，第一次调用时要做初始化，如果要做的工作比较多，性能上会有些延迟，之后就和饿汉式一样了。

1. 在getInstance方法上加同步

2. 双重检查锁定：

3. 静态内部类：

<span style="color:#3333ff">public class Singleton {    private static class LazyHolder {    private static final Singleton INSTANCE = new Singleton();    }    private Singleton (){}    public static final Singleton getInstance() {    return LazyHolder.INSTANCE;    }    
}    </span>

至于1、2、3这三种实现又有些区别，

第1种，在方法调用上加了同步，虽然线程安全了，但是每次都要同步，会影响性能，毕竟99%的情况下是不需要同步的，

第2种，在getInstance中做了两次null检查，确保了只有第一次调用单例的时候才会做同步，这样也是线程安全的，同时避免了每次都同步的性能损耗

第3种，利用了classloader的机制来保证初始化instance时只有一个线程，所以也是线程安全的，同时没有性能损耗，所以一般我倾向于使用这一种。

线程安全：一个类或者程序所提供的接口对于线程来说是原子操作，或者多个线程之间的切换不会导致该接口的执行结果存在二义性,也就是说我们不用考虑同步的问题，那就是线程安全的。

以下是一个单例类使用的例子，以懒汉式为例，这里为了保证线程安全，使用了双重检查锁定的方式：public String getName() {  return name;  }  public void setName(String name) {  this.name = name;  }  public void printInfo() {  System.out.println("the name is " + name);  }  }

public class TMain {  public static void main(String[] args){  TestStream ts1 = TestSingleton.getInstance();  ts1.setName("jason");  TestStream ts2 = TestSingleton.getInstance();  ts2.setName("0539");  ts1.printInfo();  ts2.printInfo();  if(ts1 == ts2){  System.out.println("创建的是同一个实例");  }else{  System.out.println("创建的不是同一个实例");  }  }  
}