JAVA设计模式之单例模式

1.什么是单例模式

单例模式的意思就是只允许存在一个实例。单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，避免频繁创建对象，节约内存，这个类称为单例类。

2. 前提知识

1. static修饰的成员变量或者方法，独立于该类的任何对象。它不依赖类特定的实例，被类的所有实例共享，只要这个类被加载，该成员变量或方法就可以通过类名去进行访问，它的作用是，不用创建对象就可以调用方法或者变量。

2. 使用private修饰的构造方法，不可以直接创建对象，只能通过调用方法获得：如下

public class A {
    public String name;
    // 使用private修饰的构造方法
    private A() {
        System.out.println("方法A被实例化");
    }

    public static A getInstance() {
        return new A();
    }
}

调用

public class B {
    public static void main(String[] args) {
        //这样创建会出错
        //A a = new A();
        // 调用静态方法创建对象实例
        A a = A.getInstance();
        a.name = "aaa";
        System.out.println(a.name);
    }
}

3. 单例分为饿汉式和懒汉式，又称为立即加载和延迟加载。我们可以理解为，饿了有吃的则立刻开吃，懒得动的除非你揍他它才干活。

3. 饿汉式

public class Singleton {
    private static Singleton singleton = new Singleton();
    // 私有化构造方法很重要，单例的重要特点
    private Singleton() {
    }
    // 使用内部静态方法返回实例
    public static Singleton getSingleton() {
        return singleton;
    }
}

在类加载的时候就完成了实例化，避免了多线程的同步问题。缺点是，因为类加载时就实例化了，如果该实例没被使用，则内存浪费。

4. 懒汉式

public class Singleton {
    private static Singleton singleton = null;

    private Singleton() {
    }
    // 使用内部静态方法返回实例
    public static Singleton getSingleton() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

懒汉式只有在方法第一次被访问时才会实例化，不会出现内存浪费。这样的方式有个缺点，就是多线程的安全问题（当线程1运行到if判断语句时候，线程2也运行到if语句了，这样会出现两次实例化现象），所以这种写法不可采用。

  4.1 懒汉式改进

public class Singleton {
    private static Singleton singleton = null;

    private Singleton() {
    }
    //搞把锁实现安全
    public static synchronized Singleton getSingleton() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

这样可以保证了同一时刻只能有一个线程访问并获得实例。但是synchronized是修饰整个方法，代价大，每个线程访问都要进行同步，但是实际上不安全的内容出现在实例化代码处，因此我们用synchronized修饰代码块即可，于是还可以再改进。

  4.2 懒汉式再改进

public class Singleton {
    // 注意使用了volatile关键字
    private volatile static Singleton singleton = null;

    private Singleton() {
    }
    // 利用双重检测
    public static Singleton getSingleton() {
        // 如果线程1，2都为空
        if (singleton == null) {
            // 线程1，2都进入到这里
            synchronized (Singleton.class){
                // synchronized保证只有1个线程到这里
                if (singleton == null) {
                    // 空则实例化
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

通过双重检测保证安全，同时锁加在了静态代码块处，效率高。注意的是：singleton对象使用了volatile关键字，为什么使用这个关键字个小知识点。（阿里面试官问过我，volatile关键字那种场合使用。。。当时我是懵逼的，写道这里才知道！！！）

5.通过静态内部类实现

public class Singleton {
    private Singleton() {
    }

    private static class CreateSingleton {
        // 只创建了一次
        private static final Singleton singleton = new Singleton();
    }

    // 使用内部静态方法返回实例
    public static Singleton getSingleton() {
        return CreateSingleton.singleton;
    }
}

6. 总结：

1. 当想实例化一个单例类的时候，通过相应的获取对象的方法来得到，而不是使用 new

2. 单例模式保证了 系统内存中该类只存在一个对象，节省资源

3. 对于频繁操作的对象，创建对象又需要较大的时间开销，则可以使用单例提高性能（如爬虫，爬一个网页就要new一个爬虫，不如改成一个单例来爬，如频繁访问数据库或文件的对象，在spring中jdbc连接）