设计模式详解（二）——单例模式网站首页 其他

设计模式详解（二）——单例模式

Yarrow-Y 2024-06-14 18:01:02

简介设计模式详解（二）——单例模式

单例模式简介

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，创建型模式是一类最常用的设计模式，在软件开发中应用非常广泛，它提供了一种创建对象的最佳方式。
单例模式是指在内存中只会创建且仅创建一次对象的设计模式。在程序中多次使用同一个对象且作用相同时，为了防止频繁地创建对象使得内存飙升，单例模式可以让程序仅在内存中创建一个对象，让所有需要调用的地方都共享这一单例对象。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

单例模式的特点
　1、单例类只能有一个实例。
　2、单例类必须自己创建自己的唯一实例。
　3、单例类必须给所有其他对象提供这一实例。

单例模式有两种类型：

懒汉式：在真正需要使用对象时才去创建该单例类对象。顾名思义就是实例在用到的时候才去创建，“比较懒”，用的时候才去检查有没有实例，如果有则返
饿汉式：在类加载时已经创建好该单例对象，等待被程序使用。顾名思义就是实例在用到的时候才去创建，“比较懒”，用的时候才去检查有没有实例，如果有则返。顾名思义，就是“比较勤”，实例在初始化的时候就已经建好了，不管你有没有用到，都先建好了再说。好处是没有线程安全的问题，坏处是浪费内存空间。

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

饿汉式（静态常量）
优点：在类装载的时候就完成实例化。避免了线程同步问题。
缺点：在类装载的时候就完成实例化。实现了单例，无法做到延迟加载，消耗内存。。

public class Eager{
    private final static Eager instance= new Eager();
    
    private Eager() { }
    
    public static Eager getInstance( {
        return instance;
    }
}

饿汉式（静态代码块）
这种方式和上面的方式其实类似，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例。
优点：在类装载的时候就完成实例化。避免了线程同步问题。
缺点：在类装载的时候就完成实例化。如果从始至终从未使用过这个实例，则会造成内存的浪费。

public class Eager{
    private static Eager instance;
    static {
         instance = new Eager() ;
}
private Eager() { }

public static Eager getInstance( {
     return instance;
    }
}

懒汉式（线程不安全）
这种写法只能在单线程下使用。如果在多线程下，一个线程进入了if (eager == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式。

public class Lazy{

     private static Lazy lazy;
     
     private Lazy() { }
     
     public static Lazy getInstance(){
         if (lazy == null) {
             lazy = new Lazy() ;
        }
        return lazy;
    }
}

懒汉式（线程安全，同步方法）
缺点：效率太低了，每个线程在想获得类的实例时候，执行getInstance()方法都要进行同步。

public class Lazy{
    private static Lazy lazy;
    
    private Lazy() { }
    
    public static synchronized Lazy getInstance() {
        if(lazy == null) {
            lazy = new Lazy() ;
        }
        return lazy;
    }
}

懒汉式（线程安全，同步代码块）
这种同步并不能起到线程同步的作用。跟第3种实现方式遇到的情形一致，假如一个线程进入了if (eager == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。

public class Lazy{
       private static Lazy lazy;
       
       private Lazy() { }
       
       public static Lazy getInstance() {
           if (lazy == null) {
               synchronized (Lazy.class) {
                   lazy = new Lazy() ;
             }
         }
         return lazy;
   }
}

双重检查【推荐使用】
Double-Check概念对于多线程开发者来说不会陌生，如代码中所示，我们进行了两次if (singleton == null)检查，这样就可以保证线程安全了。这样，实例化代码只用执行一次，后面再次访问时，判断if (singleton == null)，直接return实例化对象。
优点：线程安全；延迟加载；效率较高。

public class DoubleCheck{
    private static volatile DoubleCheck doublecheck ;
    
    private DoubleCheck() {}

    public static DoubleCheck getInstance() {
        if (doublecheck == null) {
            synchronized (DoubleCheck .class) {
                 if (doublecheck == null) {
                     doublecheck = new DoubleCheck () ;
                 }
            }
        }
        return doublecheck;
    }
}