单例模式

当你停下来休息的时候,不要忘记,别人还在奔跑~

单例模式的特点：

1.单例类确保自己只有一个实例。
2.单例类必须自己创建自己的实例。
3.单例类必须为其他对象提供唯一的实例。

单例模式几种实现方法:

1.懒汉式

• 只有在自身需要的时候才去行动,判断是否已经有对象,如果没有则立即创建对象然后返回;如果有对象则不再创建对象,立即返回。
• 减轻加载时的负担,缩短加载时间,提升加载效率; 同时因为是轻量级对象,把创建对象放在使用中进行, 实际上就是把创建单例对象所消耗的时间分摊到整个应用中,对整个应用中的运行效率没有太大影响。
• 运行时获取对象较慢,但加载类的时候比较快,在整个应用的生命周期只有一部分时间在占用资源.轻量级对象的单例推荐采用懒汉模式。

  public class LazySingleton {
    /**
     * 保证 instance 在所有线程中同步
     */
    private static volatile LazySingleton instance = null;
    /**
     *   private 避免类在外部被实例化
     */
    private LazySingleton() {}

    /**
     *    getInstance 方法前加 synchronized 同步
     */
     public static synchronized LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        } else {
            System.out.println("已经有一个对象!!");
        }
        return instance;
      } 
 }

2.饿汉式

• 在类加载的时候就立即创建了对象加载类的时候比较慢,但是运行时获取对象的速度比较快,他会从加载到应用结束会一直占用资源.
• 从用户角度来说,应该首选饿汉模式,因为一般用户愿意花费较长的时间等待程序初始化而不愿意在程序运行时等待太久,给人一种迟钝的感觉.所以对于有重量级对象参与单例模式,推荐使用饿汉模式.

public class HungarySingleton extends JPanel {

    private static final HungarySingleton instance = new HungarySingleton();

    private HungarySingleton() {}
    /**
     * 饿汉式单例在类创建的同时就已经创建好一个静态的对象供系统使用，
     * 以后不再改变，所以是线程安全的，
     * 可以直接用于多线程而不会出现问题。
     *
     * @return
     */
    public static HungarySingleton getInstance() {
        return instance;
    }
}

3.双检锁/双重校验锁

由于创建单例实例的时候要保证线程安全，如果使用线程安全的懒汉模式，要将getInstance()方法设为同步方法，这样当多个线程访问此方法的时候就会排队依次等待class锁的释放，这样会大大降低效率。而且在getInstance()中可能还会有一些单例实例创建之前的准备工作，这些工作是可以同步进行的，所以我们只需要把创建单例的关键代码部分设置为同步代码块，并且在进入同步代码块之前进行实例是否存在的判断即可，这就是所谓的DCL机制。

public class Singleton {  
    private volatile static Singleton singleton;  
    private Singleton (){}  
    public static Singleton getSingleton() {  
    if (singleton == null) {  
        synchronized (Singleton.class) {  
        if (singleton == null) {  
            singleton = new Singleton();  
        }  
        }  
    }  
    return singleton;  
    }  
} 

4.登记式／静态内部类

这种方式同样利用了 classloder 机制来保证初始化 instance 时只有一个线程，它跟饿汉模式不同的是：饿汉模式只要 Singleton 类被装载了，那么 instance 就会被实例化（没有达到 lazy loading 效果），而这种方式是 Singleton 类被装载了，instance 不一定被初始化。因为 SingletonHolder 类没有被主动使用，只有通过显式调用 getInstance 方法时，才会显式装载 SingletonHolder 类，从而实例化 instance，并且静态内部类只被加载一次，所以一直会创建一个单例类实例。想象一下，如果实例化 instance 很消耗资源，所以想让它延迟加载，另外一方面，又不希望在 Singleton 类加载时就实例化，因为不能确保 Singleton 类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化 instance 显然是不合适的。这个时候，这种方式相比饿汉模式就显得很合理。

public class Singleton {  
    private static class SingletonHolder {  
    private static final Singleton INSTANCE = new Singleton();  
    }  
    private Singleton (){}  
    public static final Singleton getInstance() {  
    return SingletonHolder.INSTANCE;  
    }  
} 

小结:

在应用场景中，某类只要求生成一个对象的时候，如一个班中的班长、每个人的身份证号等。
当对象需要被共享的场合。由于单例模式只允许创建一个对象，共享该对象可以节省内存，并加快对象访问速度。如 Web 中的配置对象、数据库的连接池等。
当某类需要频繁实例化，而创建的对象又频繁被销毁的时候，如多线程的线程池、网络连接池等。