单例模式的八种方式

1.饿汉式（静态常量）

//饿汉式 静态常量
class Singleton1{
    //内部创建对象实例
    private final static Singleton1 instance=new Singleton1();
    //私有化构造方法
    private Singleton1(){
    }
    //提供一个公有的静态方法 返回实例对象
    public static Singleton1 getInstance(){
        return instance;
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13

优点 ：写法简单，在类加载时就完成实例化，避免线程同步问题
缺点：在类加载时完成实例化，没有达到lazy loading的效果，如果从始至终没使用这个实例，会造成内存的浪费

这种方式基于classloader机制避免了线程同步问题，但是instance在类装载时就实例化。在单例模式种大多数都是调用getInstance方法，但是导致类加载的原因有很多，因此不能确定有其他的方式（或者其他的静态方法）导致类装在，这是初始化instance就没有达到lazy loading的效果

结论：这种单例模式可用，可能造成内存浪费

2.饿汉式（静态代码块）

class Singleton1{
    //内部创建对象实例
    private final static Singleton1 instance;
    static{
        instance=new Singleton1();
    }
    //私有化构造方法
    private Singleton1(){
    }
    //提供一个公有的静态方法 返回实例对象
    public static Singleton1 getInstance(){
        return instance;
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

与1类似

3.懒汉式（线程不安全）

class Singleton1{
    
    private final static Singleton1 instance=null;

    //私有化构造方法
    private Singleton1(){
    }
    //提供一个公有的静态方法 返回实例对象
    public static Singleton1 getInstance(){
        if(instance==null){
            return new Singleton1();
        }
        return instance;
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

优缺点：
起到了lazy loading的效果，但只能在单线程下使用
如果在多线程下，一个线程进入了if（instance==null）判断语句，还未来得及往下执行，另一个线程也通过了判断语句，会产生多个实例
结论：实际开发不要使用这种模式

4.懒汉式（线程安全，同步方法）

class Singleton1{

    private final static Singleton1 instance=null;

    //私有化构造方法
    private Singleton1(){
    }
    //提供一个公有的静态方法 返回实例对象
    public static synchronized Singleton1 getInstance(){
        if(instance==null){
            return new Singleton1();
        }
        return instance;
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

优缺点：
解决了线程安全问题
但是效率太低，每次获取实例时都要加锁。而其实这个方法只执行一次实例化代码就可以了，后面想获得该类实例，直接return就可以，方法进行同步效率太低
结论：在实际开发种，不推荐使用这种方式

5.懒汉式（线程安全 同步代码块）

class Singleton1{

    private final static Singleton1 instance=null;

    //私有化构造方法
    private Singleton1(){
    }
    //提供一个公有的静态方法 返回实例对象
    public static Singleton1 getInstance(){
        if(instance==null){
            synchronized (Singleton1.class) {
                return new Singleton1();
            }
        }
        return instance;
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

与5类似

6.双重检查

class Singleton1{

    //可能会发生指令重排序 需要加入volatile关键字
    private static volatile Singleton1 instance=null;

    //私有化构造方法
    private Singleton1(){
    }
    //提供一个公有的静态方法 返回实例对象
    public static Singleton1 getInstance(){
        if(instance==null){
            synchronized (Singleton1.class) {
                if(instance==null)
                return new Singleton1();
            }
        }
        return instance;
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

优缺点
通过两次非空检查来保证线程安全
实例化代码只运行一次，下次再访问直接return实例化对象，避免反复进行方法同步
线程安全 延迟加载效率较高

结论：实际开发种，推荐使用这种单例模式

7. 静态内部类

class Singleton1{

    //可能会发生指令重排序 需要加入volatile关键字
    private static volatile Singleton1 instance=null;

    //私有化构造方法
    private Singleton1(){
    }
    private static class SingletonInstance{
        private static final Singleton1 INSTANCE=new Singleton1();
    }
    //提供一个公有的静态方法 返回实例对象
    public static Singleton1 getInstance(){
        return SingletonInstance.INSTANCE;
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

优缺点：
1.采用了类装载的机制来保证初始化实例时只有一个线程
2.静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装在SingletonInstance类，从而完成Singleton1的实例化
3.类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的
4.优点：避免了线程不安全，利用静态内部类特点实现延迟加载，效率高
结论：推荐使用

8.枚举

enum Singleton2{
    INSTANCE;
}
1
2
3

借助JDK1.5添加的枚举来完成单例模式，不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象

单例模式在JDK中的应用

Runtime中采用了饿汉式的单例模式

注意：
单例模式保证了系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象用单例可以提高性能

单例使用场景：需要频繁的进行创建和销毁的对象，创建对象时消耗过多或耗费资源过多（重量级对象）,但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象（比如数据源、session工厂）