Java设计模式--单例模式

Java设计模式--单例模式详解

一、单例模式的定义

单例模式确保某个类只有一个实例，而且自行实例化并向整个提供提供这个实例。在计算机系统中，线程池、缓存、日志对象、对话框、打印机显卡的驱动程序对象常被设计程单例模式。这些应用或多或少既有资源管理器的功能。每台计算机可以有若干个打印机，但是只有一个Printer Spooler，以避免两个打印作业同时输出到打印机中。每台计算机可以有若干通信端口，系统应当集中管理这些通信端口，以避免一个通信端口同时被两个请求同时调用。总之，选择单例模式就是为了避免不一致状态。

二、单例模式的特点

1、某个类只能有一个实例

2、他必须自行创建这个实例

3、它必须自行向整个提供提供这个实例

三、单例模式的结构

单例模式结构图

单例模式结构图中只包含了一个单例角色：

  Singleton（单例）：在单例类的内部实现只生成一个实例，同时它提供一个静态的getInstance()工厂方法，让客户可以访问他的唯一实例；为了防止外部对其实例化，将其构造函数设计为私有；在单例类内部定义了一个Singleton类型的静态对象，作为外部共享的唯一实例。

四、单例模式的作用

1、控制资源的使用，通过线程同步来控制资源的并发访问

2、控制实例产生的数量，达到节约资源的目的。

3、作为通信媒介使用，也就是数据共享，它可以在不建立直接关联的条件下，让多个不相关的两个线程或者进程之间实现通信。

五、单例模式的使用场景

1、系统只需要一个实例对象，如系统要求提供一个唯一的序列号生成器或资源管理器，或者需要考虑资源消耗太大而只允许创建一个对象。

2、客户调用类的单个实例只允许使用一个公共访问点，除了该公共访问点，不能通过其他途径访问该实例

六、单例模式的优缺点

主要优点：

1、提供了对唯一实例的受控访问

2、由于在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象，单例模式无疑可以提高系统的性能

3、允许可变数目的实例

主要缺点：

1、由于单例模式中没有抽象层，因此单例类的扩展有很大的困难

2、单例类的职责过重，在一定程度上违背了“单一职责原则”

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

七、单例模式的其中书写方式

1、懒汉，线程不安全

public class Singleton{
    private static Singleton instance;
    private Singleton(){}
    public static Singleton getInstance(){
    if( instance == null){
        instance = new Singleton();
    }
        return instance;
    }
}

这种lazy longing的方式的写法的的致命缺点是多线程不能正常工作

2、懒汉，线程安全

public class Singleton{
    private static Singleton instance;
    
    private Singleton(){}

    public static synchronized Singleton getInstance(){
       
    if(instance == null){
        instance = new Singleton();
    }
        return instance;
    }
}

这种写法能够在多线程中很好的工作，而且看起来它也具备很好的lazy loading，但是，效率很低，99%情况下不需要同步

3、饿汉

public class Singleton{

    private static Singleton instance = new Singleton();

    private Singleton(){}

    public static Singleton getInstance(){
        return instance;
    }
}

这种方法基于classloader 机制避免了多线程的同步问题，不过，instance在类加载时就实例化，虽然导致类装载的原因有很多种在单例模式中大多数都是带哦用getInstance方法，但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance显然没有达到lazy loading的效果

4、饿汉，变种

public class Singleton{
    
    private Singleton instance = null;

    static{
        instance = new Singleton();
    }

    private Singleton(){}
    
    public static Singleton getInstance(){
        return this.instance;
    }
}

与第三种差不多，都是在类初始化即实例化

饿汉与懒汉小结：

饿汉式单例类在类被加载时就将自己实例化，它的优点在于无需考虑多线程访问问题，可以确保实例的唯一性；从调用速度和反应时间角度来讲，由于单例对象一开始就得以创建，因此要优于懒汉式单例。但是无论系统在运行时是否需要使用该单例对象，由于在类加载时该对象就需要创建，因此从资源利用效率角度来讲，饿汉式单例不及懒汉式单例，而且在系统加载时由于需要创建饿汉式单例对象，加载时间可能会比较长。

懒汉式单例类在第一次使用时创建，无须一直占用系统资源，实现了延迟加载，但是必须处理多个线程同时访问的问题，特别是当单例类作为资源控制器，在实例化时必然涉及资源初始化，而资源初始化很有可能耗费大量时间，这意味着出现多线程同时首次引用此类的几率变得较大，需要通过双重检查等机制进行控制，这将导致系统性能受到一定影响。

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;
    }
}

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

6、枚举

public enum Singleton{
    
    INSTANCE;

    public void whateverMethod(){

    }
}

这种方式是Effective Java作者Josh Bloch提倡的方式，它不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。

7、双重校验锁

public class Singleton{
    
    private volatile static Singleton singleton;

    private Singleton(){}

    public staitc Singleton getSingleton(){
        if(singleton == null){
            synchronized(Singleton.class){
                if(singleton == null){
                    singleton = new Singleton();
                }
            }
        }
        return singleton;    
    }

}

在JDK1.5之后，双重检查锁定才能正常达到单例效果。

八、注意问题

1、如果单例由不同的类加载器装入，那便有可能存在多个单例类的实例。假定不是远端存取，例如一些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));
    }
}

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

解决方案：

public class Singleton implements java.io.Serializable{
    
    public static Singleton INSTANCE = new Singleton();

    protected Singleton(){

    }

    private Object readResolve(){
        return INSTANCE;
    }
}

九、新型单例实现方法

饿汉式单例类不能实现延迟加载，不管将来用不用始终占据内存；懒汉式单例类线程安全控制繁琐，而且性能受影响。可见无论是饿汉式单例还是懒汉式单例都存在问题，下面将要介绍更好的被称为Initialization on Demand Holder(IoDH)的技术。

在IoDH中，我们在单例类中增加一个静态内部类，在该内部类中创建单例对象，再讲该对象通过getInstance（）方法返回给外部使用

public class Singleton{
    
    private Singleton(){
    }

    private static class HolderClass{
        private final static Singleton instance = new Singleton();
    }

    public staitc Singleton getInstance(){
        return HolderClass.instance;
    }
    
    public static void main(String args[]){
        Singleton s1,s2;
        s1 = Singleton.getInstance();
        s2 = Singleton.getInstance();
        System.out.println(s1 == s2);
    }
}

编译并运行上述代码，运营结果为：true,即创建的单例对象s1和s2为同一对象，由于静态单例对象没有座位Singleton的成员变量直接实例化，因此类加载时不会实例化Singleton，第一次调用getInstance()时将加载内部类HolderClass，在该内部类中定义了一个static类型的变量instance，此时会首先初始化这个成员变量，由Java虚拟机来保证其线程安全性，确保该成员变量只能初始化一次。由于getInstance()方法没有任何线程锁定，因此其性能不会造成任何影响。

通过使用IoDH，我们既可以实现延迟加载，又可以保证线程安全，不影响系统性能，不失为一种最好的Java语言单例模式实现范式

感谢：

https://www.cnblogs.com/kuoAT/p/6725808.html

https://blog.csdn.net/iblade/article/details/51107308

https://www.cnblogs.com/garryfu/p/7976546.html