Java设计模式——创建型模式之单例模式

Posted 2020-10-07 ---江北

一、概述

　　弥补一下之前没有给设计模式下的定义，先介绍一下设计模式（引用自百度百科）：

　　

设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。

使用设计模式的目的：为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。 设计模式使代码编写真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样。

 

　　设计模式概念的介绍，参见：http://blog.jobbole.com/101076/

　　其中涉及的设计原则的概念，参见随笔：http://www.cnblogs.com/jiangbei/p/6910790.html

二、单例模式

　　单例模式：保证整个应用程序中某个类的实例有且只有一个（日志对象等）

　　常见的单例分为两种——饿汉式和懒汉式

　　1.饿汉式

　　通过静态属性：

　　创建Sinleton类，此类实例只能唯一　

public class Singleton {
    // 1.构造器私有化，保证不能通过外部创建实例
    private Singleton() {

    }
    // 2.自己内部创建唯一实例
    static Singleton instance = new Singleton();
}

　　因为是静态成员，所以可以通过类.的形式访问：

public class Demo01 {
    public static void main(String[] args) {
        // 静态方法创建两个对象
        Singleton s1 = Singleton.instance;
        Singleton s2 = Singleton.instance;
        if (s1 == s2) {
            System.out.println("s1、s2是同一个实例！");
        } else {
            System.out.println("s1、s2不是同一个实例！");
        } 
    }
}

　　

　　通过静态方法：

　　考虑到我们Java中非常重要的封装的概念，我们有必要对上述代码进行改进，让属性私有化，使得外部无法直接访问：

　　新的Singleton类：

public class Singleton {
    // 1.构造器私有化，保证不能通过外部创建实例
    private Singleton() {

    }
    // 2.创建私有唯一实例
    private static Singleton instance = new Singleton();
    // 3.对外创建公共的静态方法获取实例
    public static Singleton getInstance() {
        return instance;
    }
}

　　测试类：

 public static void main(String[] args) {
        // 静态方法创建两个对象
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        if (s1 == s2) {
            System.out.println("s1、s2是同一个实例！");
        } else {
            System.out.println("s1、s2不是同一个实例！");
        }
    }

　　

 　　以上就是饿汉式的单例模式，正如其名，饿汉饿汉，饿了就要吃饭，所以它早早的（静态，类加载的时候）就创建好了实例

　　创建完实例后以后不再改变，所以天生是线程安全的。

　　2.懒汉式

　　单例类Singleton2:

public class Singleton2 {
    // 1.构造器私有化,不允许外部直接创建
    private Singleton2() {

    }
    // 2.声明静态属性（而不实例化）
    private static Singleton2 instance;
    // 3.对外提供静态获取方法
    public static Singleton2 getInstance() {
        if (instance == null) {
            instance = new Singleton2();
        }
        return instance;
    }
}

　　测试类：

  public static void main(String[] args) {
        // 静态方法创建两个对象
        Singleton2 s1 = Singleton2.getInstance();
        Singleton2 s2 = Singleton2.getInstance();
        if (s1 == s2) {
            System.out.println("s1、s2是同一个实例！");
        } else {
            System.out.println("s1、s2不是同一个实例！");
        }
    }

　　

　　懒汉式，也是和它的命名一样，懒得创建对象，初始化时只声明，第一次访问时才创建

 　　当然，不得不指出，上述懒汉式是线程不安全的，多线程下是会存在创建多个实例的问题的，为此我们通过以下的改进方法来保证线程安全：

　　　　1.在getInstance()方法上加上同步（返回值前加）：

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

　　　　2.双重检查double checking

　　补充；此种双重检查有待考察，实际中请使用饿汉式！

  public static Singleton2 getInstance() {
        if (instance == null) {
            synchronized (Singleton2.class) {
                if (instance == null) {
                    instance = new Singleton2();
                }
            }
        }
        return instance;
    }

　　// 如果没有双重检查，少了任何一重，都会出现要么性能不高，要么创建多个实例

 　　想了解更过有关单例的内容，请参见：http://blog.csdn.net/jason0539/article/details/23297037/

　　将单例模式中的静态变量（单例）推广到多个静态变量，工厂方法根据参数返回不同的变量，即引申为多例模式！这里不再展开多例模式，可以参阅《Java与模式》一书！