图解设计模式-单例模式

图解设计模式-单例模式

单例模式的八种实现方式：

1. 饿汉式（静态常量）
2. 饿汉式（静态代码块）
3. 懒汉式（线程不安全）
4. 懒汉式（线程安全，同步方法）
5. 懒汉式（线程安全，同步代码块）
6. 双重检查
7. 静态内部类
8. 枚举

代码演示：

1. 饿汉式（静态常量）

   //饿汉式(静态变量)
   class Singleton {
   	//1. 构造器私有化, 防止new
   	private Singleton() {}
   	//2.本类内部创建对象实例
   	private final static Singleton instance = new Singleton();
   	//3. 提供一个公有的静态方法，返回实例对象
   	public static Singleton getInstance() {
   		return instance;
   	}
   }
   

   优缺点：

   • 优点：写法简单，在类装载的时候就完成了实例化。避免了线程同步问题。
   • 缺点：没有延迟加载。如果从来没有使用过这个实例，就会造成内存浪费。

   结论：可用，可能会造成内存浪费。

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

   class Singleton {
   //1. 构造器私有化, 外部能 new
   private Singleton() {
   }
   //2.本类内部创建对象实例
   private static Singleton instance;
   static { // 在静态代码块中,创建单例对象
   instance = new Singleton();
   }
   //3. 提供一个公有的静态方法,返回实例对象
   public static Singleton getInstance() {
   return instance;}}
   

   优缺点：

   • 优点：写法简单，在类装载的时候就完成了实例化。避免了线程同步问题。
   • 缺点：没有延迟加载。如果从来没有使用过这个实例，就会造成内存浪费。

   结论：可用，可能会造成内存浪费。

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

   class Singleton {
   private static Singleton instance;
   private Singleton() {}
   //提供一个静态的公有方法,当使用到该方法时,才去创建 instance
   //即懒汉式
   public static Singleton getInstance() {
   if(instance == null) {
   instance = new Singleton();
   }
   return instance;}}
   

   优缺点：

   • 优点：起到了懒加载的效果，但是只能在单线程下使用。
   • 缺点：如果在多线程下,一个线程进入了 if (singleton == null)判断语句块,还未来得及往下执行,另一个线程也通过了这个判断语句,这时便会产生多个实例。所以在多线程环境下不可使用这种方式
   • 结论：在实际开发中，不要使用这种方式。

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

   // 懒汉式(线程安全,同步方法)
   class Singleton {
   private static Singleton instance;
   private Singleton() {}
   //提供一个静态的公有方法,加入同步处理的代码,解决线程安全问题
   //即懒汉式
   public static synchronized Singleton getInstance() {
   if(instance == null) {
   instance = new Singleton();
   }
   return instance;}}
   

   优缺点：

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

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

   class Singleton {
   private static Singleton instance;
   private Singleton() {}
   //即懒汉式
   public static  Singleton getInstance() {
   if(instance == null) {
       synchronized(Singleton.class){
           instance = new Singleton();
       }}
   return instance;}}
   

   结论：不推荐使用！！！

6. 双重检查

   // 懒汉式(线程安全,同步方法)
   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概念是多线程开发中常使用到的，这样就可以保证线程安全了。线程安全，延迟加载，效率较高
   • 结论：在实际开发中，推荐使用这种单例设计模式。

7. 静态内部类

   // 静态内部类完成, 推荐使用
   class Singleton {
   //volatile:在访问volatile变量时不会执行加锁操作，因此也就不会使执行线程阻塞，因此volatile变量是一种比sychronized关键字更轻量级的同步机制。
   private static volatile Singleton instance;
   //构造器私有化
   private Singleton() {}
   //写一个静态内部类,该类中有一个静态属性 Singleton
   private static class SingletonInstance {
   private static final Singleton INSTANCE = new Singleton();
   }
   //提供一个静态的公有方法,直接返回 SingletonInstance.INSTANCE
   public static synchronized Singleton getInstance() {
   return SingletonInstance.INSTANCE;
   	}
   }
   

   优缺点：

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

8. 枚举

   public class SingletonTest08 {
   public static void main(String[] args) {
   Singleton instance = Singleton.INSTANCE;
   Singleton instance2 = Singleton.INSTANCE;
   System.out.println(instance == instance2);
   System.out.println(instance.hashCode());
   System.out.println(instance2.hashCode());
   instance.sayOK();
   }
   }
   //使用枚举,可以实现单例, 推荐
   enum Singleton {
   INSTANCE; //属性
   public void sayOK() {
   System.out.println("ok~");
   }
   }
   

   优缺点：

   • 优点：
     • 这借助 JDK1.5 中添加的枚举来实现单例模式。不仅能避免多线程同步问题,而且还能防止反序列化重新创建
       新的对象。
     • 这种方式是 Effective Java 作者 Josh Bloch 提倡的方式
     • 枚举类的每一个属性都是这个类的一个实例对象。
   • 结论：推荐使用

验证单例对象

public static void main(String[] args) {
System.out.println("验证方式");
Singleton instance = Singleton.getInstance();
Singleton instance2 = Singleton.getInstance();
System.out.println(instance == instance2); // true
System.out.println("instance.hashCode=" + instance.hashCode());
System.out.println("instance2.hashCode=" + instance2.hashCode());
}