Java设计模式--单例模式

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

一、单例模式的定义

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

二、单例模式的特点

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

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

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

三、单例模式的结构

Java设计模式--单例模式_第1张图片 单例模式结构图

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

  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

你可能感兴趣的:(Java设计模式--单例模式)