单例设计模式常见的七种写法

饿汉式：类加载时单实例对象被创建

第一种：静态成员变量

public class Singleton {

    //私有构造方法
    private Singleton() {}

    //创建对象
    private static Singleton instance = new Singleton();

    //公共获取方法
    public static Singleton getInstance() {
        return instance;
    }

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

第二种：静态代码块

public class Singleton {

    //私有构造方法
    private Singleton() {}

    //声明
    private static Singleton instance;

    //在静态代码块中进行赋值
    static {
        instance = new Singleton();
    }

    //公共访问
    public static Singleton getInstance() {
        return instance;
    }

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

---

饿汉式缺点：只要进行了类加载，对象就创建出来了，容易造成内存的浪费

---

懒汉式：首次使用该对象时才会创建

第三种：线程不安全的方式，多线程环境下会出现安全问题

public class Singleton {

    //私有构造方法
    private Singleton() {}

    //声明
    private static Singleton instance; 

    //访问
    public static Singleton getInstance() {
    	//保证单例
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }

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

第四种：线程安全方式，加上synchronized修饰

public class Singleton {

    //私有构造方法
    private Singleton() {}

    //声明
    private static Singleton instance; 

    //访问
    public static synchronized Singleton getInstance() {
    	//保证单例
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }

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

---

线程安全&&线程不安全方式缺点：读操作效率较低

---

第五种：双重检查锁方式

public class Singleton {
    //私有构造方法
    private Singleton() {}

    //volatile 保证有序性
    private static volatile Singleton instance;

    public static Singleton getInstance() {
        //首先判断是否为空，不为空直接返回，减少不必要抢占锁
        if (instance == null) {
            synchronized (Singleton.class) {

                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

第六种：静态内部类方式

public class Singleton {

    private Singleton() {}

    //静态内部类
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

第七种：枚举方式

//就是这么简单
public enum Singleton {
    INSTANCE;
}
1
2
3
4

OVER(∩_∩)O~