设计模式之单例模式

什么是单例模式

所谓类的单例模式，就是就采取一定的方法保证整个软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个获取其对象实例的方法（静态方法）。

怎么实现单例模式

步骤如下：
a、构造器私有化（防止new）
b、类的内部创建对象
c、向外暴露一个静态的公共方法。getInstance（）
d、代码实现

• 饿汉式（静态常量）

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

• 饿汉式（静态代码块）

//饿汉式（静态变量）
class Singleton{
   //1、构造方法私有化，防止new
   private Singleton(){
   }
   //2、 本类内部创建对象实例
   private  static Singleton instance;

   static { //在静态代码块中进行对象实例初始化
       instance = new Singleton();
   }
   //3 提供公有的方法返回实例对象
   public static Singleton getInstance(){
       return instance;
   }
}

• 懒汉式（线程不安全）

//懒汉式（线程不安全）
class Singleton{
   //1、构造方法私有化，防止new
   private Singleton(){
   }
   //2、 本类内部创建对象实例
   private static Singleton instance;
   //3 提供公有的方法返回实例对象
   public static Singleton getInstance(){
       if(instance == null){
           instance = new Singleton();
       }
       return instance;
   }
}

• 懒汉式（线程安全）

//懒汉式（线程安全）
class Singleton{
   //1、构造方法私有化，防止new
   private Singleton(){
   }
   //2、 本类内部创建对象实例
   private static Singleton instance;
   //3 提供公有的方法返回实例对象
   public static synchronized Singleton getInstance(){
       if(instance == null){
           instance = new Singleton();
       }
       return instance;
   }
}

• 双重检查
  解决了线程安全问题，实现懒加载，同时也提高了效率。

//懒汉式（线程安全）
class Singleton{
   //1、构造方法私有化，防止new
   private Singleton(){
   }
   //2、 本类内部创建对象实例,volatile保证变量共享
   private static volatile Singleton instance;
   //3 提供公有的方法返回实例对象
   public static  Singleton getInstance(){
   		if(instance == null){
           synchronized (Singleton.class){
               if(instance == null){
                   instance = new Singleton();
               }
           }
       }

       //如果不加第一层判断，试想如果又两个进程a，b，如果a献过得了锁，对对象进行了实例化，
       // 但是还没有释放锁，这是如果没有第一层判断，b就只能阻塞等待a进程退出，速度就会降低。
       //如果有第一层判断，b进程就会直接进行返回。
//            synchronized (Singleton.class){
//                if(instance == null){
//                    instance = new Singleton();
//                }
//            }

       return instance;
   }

• 静态内部类

//静态内部类，通过是使用jvm类加载器机制来实现线程安全
class Singleton {
   //1、构造方法私有化，防止new
   private Singleton() {
   }

   //创建一个内部类，该内部类在Singleton类别加载时并不会直接加载，
   //而是在调用getInstance（）方法后进行加载，从而实现懒加载。
   //同时利用jvm类加载机制是线程安全的来实现线程安全 。
   private static class singletonInstance {
       private static final Singleton SINGLETON = new Singleton();
   }

   //3 提供公有的方法返回实例对象
   public static Singleton getInstance() {
       return singletonInstance.SINGLETON;
   }

• 枚举实现单例模式

enum  SingleTon{
   SINGLE_TON;
   public void hello(){
       System.out.println("hello,Singleton");
   }
   

单例模式有什么用处