乐趣区

关于java:设计模式之单例模式

作者：

jiezi

在

单例模式

创立型模式

这种模式波及到一个繁多的类，该类负责创立本人的对象，同时确保只有单个对象被创立。这个类提供了一种拜访其惟一的对象的形式，能够间接拜访，不须要实例化该类的对象。

留神：

  • 1、单例类只能有一个实例。
  • 2、单例类必须本人创立本人的惟一实例。
  • 3、单例类必须给所有其余对象提供这一实例。

介绍

用意： 保障一个类仅有一个实例，并提供一个拜访它的全局拜访点。

次要解决： 一个全局应用的类频繁地创立与销毁。

何时应用： 当您想管制实例数目，节俭系统资源的时候。

如何解决： 判断零碎是否曾经有这个单例，如果有则返回，如果没有则创立。

要害代码： 构造函数是公有的。

具体实现

1.饿汉式(动态变量)

public class SingletonTest01 {

    public static void main(String[] args) {
        Singleton singleton01 = Singleton.getInstance();
        Singleton singleton02 = Singleton.getInstance();
        System.out.println(singleton01 == singleton02); //true
        System.out.println("singleton01.hashCode = " + singleton01.hashCode()); //1625635731
        System.out.println("singleton01.hashCode = " + singleton01.hashCode()); //1625635731
    }

}

/**
 * 饿汉式(动态变量)
 */
class Singleton {
    //1.结构器私有化， 内部不能new
    private Singleton() {
    }

    //2.创立实例
    private final static Singleton instance = new Singleton();

    //3.提供一个私有的静态方法，返回实例对象
    public static Singleton getInstance() {
        return instance;
    }

}

长处:

这种写法比较简单，就是在类装载的时候就实现了实例化。防止了线程同步问题 。

毛病:

在类装载的时候就实现了实例化，没有达到Lazy Loading的成果。如果从始至终都没有应用过这个实例 , 则会造成内存的节约。

总结:

这种单例模式能够应用 ，可能会造成内存节约。

2.饿汉式(动态代码块)

public class SingletonTest02 {

    public static void main(String[] args) {
        Singleton singleton01 = Singleton.getInstance();
        Singleton singleton02 = Singleton.getInstance();
        System.out.println(singleton01 == singleton02); //true
        System.out.println("singleton01.hashCode = " + singleton01.hashCode()); //1625635731
        System.out.println("singleton01.hashCode = " + singleton01.hashCode()); //1625635731
    }

}

/**
 * 饿汉式(动态代码块)
 */
class Singleton {
    //1.结构器私有化，内部不能new
    private Singleton() {
    }

    //2.申明实例
    private final static Singleton instance;

    //3.创立实例
    static {
        instance = new Singleton();
    }

    //4.提供一个私有的静态方法，返回实例对象
    public static Singleton getInstance() {
        return instance;
    }

}

总结:

这种形式的优缺点和第一种相似，只不过将类的实例化过程放在了动态代码块中，仍然可能造成内存节约。

3.懒汉式(线程不平安)

public class SingletonTest03 {

    public static void main(String[] args) {
        Singleton singleton01 = Singleton.getInstance();
        Singleton singleton02 = Singleton.getInstance();
        System.out.println(singleton01 == singleton02); //true  (有可能为false)
        System.out.println("singleton01.hashCode = " + singleton01.hashCode()); //1625635731
        System.out.println("singleton01.hashCode = " + singleton01.hashCode()); //1625635731
    }

}

/**
 * 懒汉式(线程不平安)
 */
class Singleton {

    private Singleton() {
    }

    public static Singleton instance;

    //提供一个动态的私有办法，当应用到该办法时，才会创立instance
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

长处:

起到了Lozy Loading的成果，然而只能在单线程的环境下应用。

毛病:

如果在多线程环境下，大概率会产生多个实例。所以在多线程环境下不要应用这种形式。

总结:

理论开发中不要应用这种形式。

4.懒汉式(线程平安)

public class SingletonTest04 {

    public static void main(String[] args) {
        Singleton singleton01 = Singleton.getInstance();
        Singleton singleton02 = Singleton.getInstance();
        System.out.println(singleton01 == singleton02); //true
        System.out.println("singleton01.hashCode = " + singleton01.hashCode()); //1625635731
        System.out.println("singleton01.hashCode = " + singleton01.hashCode()); //1625635731
    }
}

/**
 * 懒汉式(线程平安)
 */
class Singleton {

    private Singleton() {
    }

    public static Singleton instance;

    //提供一个动态的私有办法，当应用到该办法时，才会创立instance。
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

长处:

解决了线程不平安的问题。

毛病:

效率太低，因为是对整个办法加上了线程同步，其实只有在new的时候思考线程同步就行了，这种办法不举荐应用。

总结:

在理论开发中 ，不举荐应用这种形式 。

5.懒汉式(双重查看锁)

public class SingletonTest05 {

    public static void main(String[] args) {
        Singleton singleton01 = Singleton.getInstance();
        Singleton singleton02 = Singleton.getInstance();
        System.out.println(singleton01 == singleton02); //true
        System.out.println("singleton01.hashCode = " + singleton01.hashCode()); //1625635731
        System.out.println("singleton01.hashCode = " + singleton01.hashCode()); //1625635731
    }

}

/**
 * 懒汉式(线程平安,双重查看锁)
 */
class Singleton {

    private Singleton() {
    }

    public static volatile Singleton instance;

    //提供一个动态的私有办法，退出双重查看代码，解决线程平安问题，同时解决懒加载问题
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

长处:

这种形式采纳双锁机制，平安且在多线程状况下能放弃高性能。

总结:

在理论开发中,举荐应用这种单例设计模式 。

6.动态外部类

public class SingletonTest06 {
    public static void main(String[] args) {
        Singleton singleton01 = Singleton.getInstance();
        Singleton singleton02 = Singleton.getInstance();
        System.out.println(singleton01 == singleton02); //true
        System.out.println("singleton01.hashCode = " + singleton01.hashCode()); //1625635731
        System.out.println("singleton01.hashCode = " + singleton01.hashCode()); //1625635731
    }

}

/**
 * 动态外部类
 */
class Singleton {

    private Singleton() {
    }

    //动态外部类中蕴含一个动态属性 Singleton
    private static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonInstance.INSTANCE;
    }

}

长处:

  1. 这种形式能达到双检锁形式一样的效用，但实现更简略。
  2. 这种形式采纳了类装载的机制来保障初始化实例时只有一个线程。
  3. 动态外部类的形式在Singleton类被装载的时候并不会立刻初始化 , 而是在须要实例化时，调用getInstance办法才会装载SingletonInstance类，从而实现Singleton的实例化 。
  4. 类的动态属性只会在第一次加载类的时候进行初始化，所以这里JVM保障了线程安全性，在类进行初始化的时候 , 别的线程是无奈进入的 。

总结:

防止了线程不平安，利用动态外部类的特点实现了提早加载，效率高 ，举荐应用 。

7.枚举

public class SingletonTest07 {

    public static void main(String[] args) {
        Singleton instance1 = Singleton.INSTANCE;
        Singleton instance2 = Singleton.INSTANCE;
        System.out.println(instance1 == instance2);
    }

}

/**
 * 枚举
 */
enum Singleton {
    INSTANCE;
}

长处:

这种实现形式还没有被宽泛采纳，但这是实现单例模式的最佳办法 。它更简洁，主动反对序列化机制，相对避免屡次实例化 。
这种形式是《 Effective Java 》作者 Josh Bloch 提倡的形式，它不仅能防止多线程同步问题 ，而且还主动反对序列化机制，避免反序列化从新创立新的对象，相对避免屡次实例化。

总结:

如果波及到反序列化对象的时候能够采纳采纳这种形式，平时应用能够采纳第五种。

评论

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

这个站点使用 Akismet 来减少垃圾评论。了解你的评论数据如何被处理。

更多文章