基本介绍：
单例模式：也叫单件模式，可以用来创建独一无二的，只能有一个实例的对象，并且该类只提供一个取得其对象实例的方法(static)！它是所有设计模式中最简单的，它的类图只有一个类：
1）饿汉式（静态常量）
创建的步骤：
1.构造器私有化（防止 new来获得实例）
2.类的内部创建对象
3.向外界暴露一个静态的公共方法。getInstance
4.代码实现
1 | //饿汉式（静态变量) |
测试结果
两个对象实例的hashCode值相等，说明 new的两个对象是同一个，这样就避免了new实例多个对象！优缺点：
优点：这种写法比较简单，就是在类装载的时候就完成 了实例化，避免了线程同步问题。
缺点：
1.在类装载时就完成 了实例化，油源有达到Lazy Loading的效果，如果从始至终从未使用过这个实例，则会造成内存的浪费。
2.这种方式基于classLoader机制避免了多线程的同步问题，不过，Instance在类装载时就实例化，在单例模式中大多数都是调用getInstance方法，但是导致类装载的原因有很多种，因此不能确定有其他的方式导致类装载，这时候初始化instance就没有达到Lazy Loading的效果。结论：
这种单例模式可用，可能会造成内存浪费！
2）饿汉式（静态代码块）
这和方式和静态常量方法类似 ，只是在内部将创建实例对象的操作放到了静态代码块中进行了
- 代码实现
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31//饿汉式（静态代码块）
class Singleton{
//1.构造器私有化
private Singleton(){
}
//2.本类内部创建对象实例
private final static Singleton instance;
static {//在静态代码块中创建单例对象
instance = new Singleton();
}
//3.提供一个公有的静态方法，返回实例对象
public static Singleton getInstance(){
return instance;
}
}
public class Singleton2 {
public static void main(String[] args) {
Singleton instance = Singleton.getInstance();
Singleton instance1 = Singleton.getInstance();
System.out.println("instance:"+instance.hashCode()+"\n"+"instance1:"+instance1.hashCode());
}
} - 运行结果
- 结论：
这种单例模式也是可用的，但是可能会造成内存浪费
3）懒汉式（线程不安全）
代码实现
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24public class SingletonTest03 {
public static void main(String[] args) {
Singleton instance = Singleton.getInstance();
Singleton instance1 = Singleton.getInstance();
System.out.println(instance == instance1);
System.out.println("instance:"+instance.hashCode()+"\n"+"instance1:"+instance1.hashCode());
}
}
class Singleton{
private static Singleton instance;
private Singleton(){}
//提供一个静态的公有方法，使用到该方法时，才去创建instance
public static Singleton getInstance(){
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}运行结果
总结：
提供一个静态的公有方法，使用到该方法时，才去创建instance
1.起到了Lazy Loading的效果，但是只能在单线程下使用
2.如果在多线程下，一个线程进入了if(singleton == null)判断语句时，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式结论：
在实际开发中，不要使用这种方式。
4）懒汉式（线程安全，同步方法）
- 代码实现
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26public class SingletonTest04 {
public static void main(String[] args) {
System.out.println("懒汉式（线程安全，同步方法）");
Singleton instance = Singleton.getInstance();
Singleton instance1 = Singleton.getInstance();
System.out.println(instance == instance1);
System.out.println("instance:"+instance.hashCode()+"\n"+"instance1:"+instance1.hashCode());
}
}
//懒汉式（线程安全，同步方法）
class Singleton{
private static Singleton instance;
private Singleton(){}
//提供一个静态的公有方法,加入同步处理的代码，解决线程安全问题
//synchronized
public static synchronized Singleton getInstance(){
if (instance == null) {
instance = new Singleton();
}
return instance;
}
} - 运行结果
- 总结：
- 解决了线程不安全问题
- 效率太低了，每个线程都在想获得类的实例时候，执行getInstance()方法都要进行执行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该实例，直接return 就行了，方法进行同步的效率太低了。
- 总结
在实际开发中，不推荐使用这种方式
5）懒汉式（线程安全，同步代码块）
1 | public class SingletonTest05 { |
- 运行结果
- 总结：
- 这种方式，本意是想对第四种方式的改进，因为前面同步方法效率太低了，改为同步 产生实例化的代码块。
- 但是这种同步并不能起到线程同步的作用。，假如一个线程进入到if(Singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。
- 结论：
在实际开发中，不能使用这种方式。
6）双重检查（推荐使用）
- 代码实现
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31public class SingletonTest06 {
public static void main(String[] args) {
System.out.println("双重检查");
Singleton instance = Singleton.getInstance();
Singleton instance1 = Singleton.getInstance();
System.out.println(instance == instance1);
System.out.println("instance:"+instance.hashCode()+"\n"+"instance1:"+instance1.hashCode());
}
}
//懒汉式（线程安全，同步方法）
class Singleton{
private static volatile Singleton instance;
private Singleton(){}
//提供一个静态的公有方法,加入双重检查代码，解决线程安全问题，同时解决懒加载问题
//同时保证了效率
public static Singleton getInstance(){
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null){
instance = new Singleton();
}
}
}
return instance;
}
} - 运行结果
- 总结
- Double-Check概念是多线程开发中学使用到的，我们进行了两次if (instance == null)检查，这样就可以保证线程安全了
- 这样，实例化代码只执行一次，后面再次访问时，判断if (instance == null)，直接 return实例化对象，也就避免了反复执行方法同步 。
- 线程安全，延迟加载，效率较高
- 结论：
在开发中，推荐使用这种单例设计模式!
7）静态内部类（推荐使用）
基本介绍：
- 静态内部类不会在类装载时，直接执行，保证了懒加载
- 在调用类中的方法时，再装载静态内部类，是可行的，JVM中进行类装载时是线程安全的
- 代码实现
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28public class SingletonTest7 {
public static void main(String[] args) {
System.out.println("静态内部类：单例模式");
Singleton instance = Singleton.getInstance();
Singleton instance1 = Singleton.getInstance();
System.out.println(instance == instance1);
System.out.println("instance:"+instance.hashCode()+"\n"+"instance1:"+instance1.hashCode());
}
}
//静态内部类
class Singleton{
private static volatile Singleton instance;
private Singleton(){}
//静态内部类
private static class SingletonInstance{
private static final Singleton INSTANCE = new Singleton();
}
//提供一个静态的公有方法,直接返回SingletonInstance.INSTANCE
public static Singleton getInstance(){
return SingletonInstance.INSTANCE;
}
} - 运行结果
- 总结
1.这种方式采用了类装载的机制来保证初始化实例时只有一个线程。
2.静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会被装载SingletonInstance类，从而完成Singleton的实例化。
3.类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。
4.优点：避免了线程不安全，利用静态内部类特点实现延迟加载，效率高。 - 结论
推荐使用！
8）枚举方式
- 代码实现
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20public class SingletonTest08 {
public static void main(String[] args) {
Singleton instance = Singleton.INSTANCE;
Singleton instance1 = Singleton.INSTANCE;
System.out.println(instance == instance1);
System.out.println(instance.hashCode());
System.out.println(instance1.hashCode());
instance.sayHello();
}
}
//使用枚举可以实现单例，推荐作用
enum Singleton{
INSTANCE;
public void sayHello(){
System.out.println("hello enum");
}
} - 运行结果
- 总结：
1.借助JDK1.5中添加的枚举来实现单例模式，不仅可以避免多线程同步 问题，而且还能防止反序列化重新创建新的对象
- 结论：
强力推荐使用！！！
整理不易，如果大家觉得好的话，可以加关注，后续会整理更多的知识点！