`

Java单例模式的五种写法

阅读更多

        在网上看到《单例模式的七种写法》,写的非常好,于是转载过来学习学习,在此我按原博客一位读者同学的分类,分成懒汉、恶汉、静态内部类、枚举和双重校验锁五种。

        第一种(懒汉,线程安全):

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%情况下不需要同步。

       第二种(饿汉):

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

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

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

        表面上看起来差别挺大,其实跟饿汉方式差不多,都是在类初始化即实例化instance。

        第三种(静态内部类):

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显然是不合适的。这个时候,这种方式相比饿汉方式就显得很合理。

        第四种(枚举):

public enum Singleton {
    INSTANCE;
    public void whateverMethod() {
    }
}

       这种方式是Effective Java作者Josh Bloch 提倡的方式,它不仅能避免多线程同步问题,而且还能防止反序列化重新创建新的对象,可谓是很坚强的壁垒啊,不过,个人认为由于1.5中才加入enum特性,用这种方式写不免让人感觉生疏,在实际工作中,我也很少看见有人这么写过。

        第五种(双重校验锁):

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

        这个是第二种方式的升级版,俗称双重检查锁定,详细介绍请查看:http://www.ibm.com/developerworks/cn/java/j-dcl.html

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

 

总结

有两个问题需要注意:

        1.如果单例由不同的类装载器装入,那便有可能存在多个单例类的实例。假定不是远端存取,例如一些servlet容器对每个servlet使用完全不同的类装载器,这样的话如果有两个servlet访问一个单例类,它们就都会有各自的实例。

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

        对第一个问题修复的办法是:

private static Class getClass(String classname)    
                                         throws ClassNotFoundException {   
      ClassLoader classLoader = Thread.currentThread().getContextClassLoader();   
    
      if(classLoader == null)   
         classLoader = Singleton.class.getClassLoader();   
    
      return (classLoader.loadClass(classname));   
   }   
}

        对第二个问题修复的办法是:

public class Singleton implements java.io.Serializable {   
   public static Singleton INSTANCE = new Singleton();   
    
   protected Singleton() {   
      
   }   
   private Object readResolve() {   
            return INSTANCE;   
      }  
}

        对我来说,我比较喜欢第二种(饿汉)和第三种(静态内部类)方式,简单易懂,而且在JVM层实现了线程安全(如果不是多个类加载器环境),一般的情况下,我会使用第二种(饿汉)方式,只有在要明确实现lazy loading效果时才会使用第三种(静态内部类)方式,另外,如果涉及到反序列化创建对象时我会试着使用枚举的方式来实现单例,不过,我一直会保证我的程序是线程安全的,而且我永远不会使用第一种方式,如果有其他特殊的需求,我可能会使用第五种(双重校验锁)方式,毕竟,JDK1.5已经没有双重检查锁定的问题了。

分享到:
评论

相关推荐

    java-单例模式几种写法

    在Java中,实现单例模式有多种方法,每种方法都有其特点和适用场景。以下是对这六种常见单例模式实现方式的详细解释: 1. **饿汉式(静态常量)** 这是最简单的单例实现,它在类加载时就创建了实例,线程安全。 `...

    Java设计模式之单例模式的七种写法

    Java设计模式之单例模式的七种写法 单例模式是一种常见的设计模式,它确保某个类只有一个实例,而且自行实例化并向整个系统提供这个实例。在计算机系统中,线程池、缓存、日志对象、对话框、打印机的驱动程序对象常...

    java单例模式开发的7种写法

    ### Java单例模式开发的七种写法 #### 概述 单例模式是一种常用的软件设计模式,其目的是确保一个类仅有一个实例,并提供一个全局访问点。在Java编程语言中,实现单例模式的方法有很多种,不同的实现方式具有不同的...

    单例模式的七种写法

    单例模式是软件设计模式中的一种经典模式,用于确保一个类只有一个实例,并提供一个全局访问点。这种模式在很多场景下都非常有用,比如控制数据库连接、管理缓存或者全局配置等。下面我们将详细探讨单例模式的七种...

    java单例模式详解Java系列2021.pdf

    综上所述,单例模式在Java中的实现有多种方式,每种方式都有它的适用场景和潜在风险。开发者需要根据具体需求和环境选择合适的实现方式,并注意可能出现的问题,如线程安全、内存可见性和反射攻击等,来保证单例模式...

    Java:单例模式的七种写法

    枚举在Java中是一个特殊的语法结构,它天然支持单例模式,INSTANCE是Singleton枚举类型下的一个元素,相当于单例的实例,通过Singleton.INSTANCE可以直接访问到单例。此外,枚举的写法简洁明了,易于理解和维护。 ...

    单例的多种写法和说明比较

    单例模式是软件设计模式中的一种,用于控制类的实例化过程,确保一个类在整个程序运行期间只有一个实例存在。在Java、C#等面向对象语言中,单例模式被广泛应用,尤其是在需要频繁创建和销毁的对象,或者需要全局访问...

    java单例模式看这一篇就够了

    Java中的单例模式是一种设计模式,它用于保证一个类在整个应用程序中只能有一个实例存在。这样做的目的是为了控制实例化过程,避免多个实例间的资源冲突,同时提供全局访问点。单例模式属于创建型设计模式,它在软件...

    Tom_20170324_Java设计模式之单例模式的七种写法1

    2、单例类必须自己创建自己的唯一实例 3、单例类必须给所有其他对象提供这一实例 2、资源加载和性能:饿汉式在类创建的同时就实例化一个静态对象出来,不管之后会不会

    JavaSE单例模式各种写法.doc

    每种单例模式都有其适用场景: - **懒汉式(线程不安全)**适用于简单的、非并发环境。 - **懒汉式(线程安全)**在需要保证线程安全的情况下使用,但性能较低。 - **饿汉式**适用于对性能要求较高的情况,不支持...

    详解java中的6种单例写法及优缺点

    详解java中的6种单例写法及优缺点 在 Java 中,单例是一种常用的设计模式,它可以确保一个类只有一个实例,并提供一个全局访问点来访问该实例。单例模式可以应用于各种场景,如数据库连接池、日志记录器、线程池等...

    Java设计模式单例模式(Singleton)用法解析

    懒汉式单例模式的实现方式是在第一种基础上添加了synchronized关键字保证了线程安全。这种写法在并发高的时候虽然保证了线程安全,但是效率很低,高并发的时候所有访问的线程都要排队等待。 恶汉式(线程安全): ...

    设计模式_创建型_单例模式.md

    Java的枚举提供了一种天然的单例模式实现。Java中的枚举类型是线程安全的,并且只会装载一次,设计者充分考虑了线程安全问题。因此,枚举的写法也是实现单例模式的最佳实践。 ## 单例模式可能遇到的问题 ### 反...

    01 设计模式之单例模式.pdf

    双重检查锁定是一种优化懒汉式单例模式的写法,它可以在多线程环境中保证实例的唯一性,同时避免不必要的同步开销。通过在声明实例变量时加上volatile关键字,可以确保在读取该变量时不会发生指令重排序,从而保证了...

Global site tag (gtag.js) - Google Analytics