设计模式之单例模式

单例模式（Singleton）：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

一、单例模式

单例模式是设计模式中常见的设计模式，单例模式有以下特点：

单例类只能有一个实例。
单例类必须自己创建自己的唯一实例。
单例类必须给所有的对象提供这一个实例。

单例模式的UML图：

Singleton类，将这个类的构造器私有化，使得在外部对象中，无法通过构造器来创建Singleton的实例，只能由该类自己创建。定义一个getInstance()方法，允许用户访问它的唯一实例，是一个静态方法。

代码部分：

class Singleton{
    private static Singleton instance= null;

    private Singleton() {
    }

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

客户端：

public class Test {
    public static void main(String[] args) {
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        if(s1 == s2){
            System.out.println("s1和s2是两个相同的实例");
        }
    }
}

测试结果（代码亲测，可以通过）：

代码地址：Singleton

单例模式使得在内存中只存在一个实例，减少了内存的开销，避免了对资源的多重占用。

二、单例模式的七种写法

1.懒汉式（上面的例子就是懒汉式），线程不安全。

class Singleton{

    private static Singleton instance;
    private Singleton() {
    }

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

2.懒汉式，线程安全

class Singleton1{
    private static Singleton1 instance;
    private Singleton1() {
    }

    public static synchronized Singleton1 getSingleton(){
        if(instance == null){
            instance = new Singleton1();
        }
        return instance;
    }
}

3.饿汉式

class Singleton2{
    private static Singleton2 instance = new Singleton2();
    private Singleton2() {
    }

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

4.饿汉式，变种。

class Singleton3{
    private static Singleton3 instance;
    static{
        instance = new Singleton3(); 
    }

    private Singleton3(){}

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

5.通过静态内部类，使得Singleton类被装载了，instance不一定被初始化。因为SingletonHolder类没有被主动使用，只有显示通过调用getInstance方法时，才会显示装载SingletonHolder类，从而实例化instance。

class Singleton5{

    private static class SinglentonHolder{
        private static final Singleton5 INSTANCE = new Singleton5();
    }

    private Singleton5() {
    }
    public static final Singleton5 getInstance(){
        return SinglentonHolder.INSTANCE;
    }
}

6.枚举

    enum Singleton10 {
        INSTNCE;
        public void something(){
        }
    }

7.双重锁机制，俗称双重检查锁定。synchronized关键字锁定的是对象，在使用的时候，一定要在恰当的地方使用。

class Singleton7{
    private volatile static Singleton7 instance;
    private Singleton7(){}

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

欢迎大家评论留言，点击查看更多设计模式。