设计模式之单例模式

设计模式之单例模式

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

• 单例模式注意事项：
  1.单例模式保证了系统内存中只存在一个对象，节省了系统资源 对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能
  2.当想实例化以一个大单例类的时候，必须要记住使用相应的获取对象的方法，而不是直接new
  3.单例模式使用场景：需要频繁的进行创建和销毁的对象，创建对象时耗时过多或 耗费资源过多（即：重量级对象），但又经常用到的对象，工具类对象，频繁访问数据库或文件的对象（比如：数据源，session工厂等）

  1.饿汉式单例模式（静态常量）

public class SingletonTest01 {
    //私有构造方法 防止被New
    private SingletonTest01(){ }
    //私有静态变量
    private final static SingletonTest01  instance = new SingletonTest01();
    public static SingletonTest01 getInstance(){
        return instance;
    }

    public static void main(String[] args) {
        SingletonTest01 test1 = SingletonTest01.getInstance();
        SingletonTest01 test2 = SingletonTest01.getInstance();
        System.out.println(test1==test2);//true
    }
}

优缺点：
1.优点：写法简单，在类加载时完成实例化，避免了线程同步问题
2.缺点：在类加载时就完成实例化，没有达到Lazy Loading的效果。如果从始至终没有使用过这个实例，则会造成内存浪费。

• 结论：这种单例模式可用，但是可能造成内存浪费

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

public class SingletonTest02 {
    private static SingletonTest02 instance;
    private SingletonTest02(){ }
    static {
        //在静态代码块中创建单例对象
        instance =new SingletonTest02();
    }
    //创建一个公共的静态方法，返回实例对象
    public static SingletonTest02 getInstance(){
        return instance;
    }
}

优缺点：与第一种写法 类似，只不过将实例化过程放在静态代码块中。

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

public class LazySingleton {
    private  static LazySingleton instance = null;
    private LazySingleton(){}

    /**
     * 提供一个静态的公有方法，当使用该方法时，再去创建实例
     * @return instance
     */
    //线程不安全
    public static LazySingleton getInstance(){
        if(instance==null){
                instance = new LazySingleton();
        }
        return instance;
    }
}

优缺点：
优缺点：
1.起到了Lazy Loading的效果，但是只能在单线程下使用
2.如果在多线程情况下，一个线程进入了if(instance==null)语句块，
还未来得及创建实例，另一个线程也通过了这个判断语句，就会产生多个实例

• 结论：在实际开发中不要使用这种方式

4.懒汉式单例模式（线程安全，低效）

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

优缺点：
1.解决了线程不安全的问题
2.效率太低了，每个线程在想获得类的实例的时候，
执行getInstance()方法都要进行同步。而其实这个方法 只执行一次代码就够了，后面的要想获得实例，直接return就行。

• 结论：在实际开发中，不推荐使用这种方式

5.懒汉式单例模式（线程安全，高效）

public class LazySingleton03 {
    private static volatile LazySingleton03 instance;
    private LazySingleton03(){
    }
    /**提供一个静态的公用方法，加入双重检查代码，解决线程安全问题，
     *同时解决懒加载问题
     */
    public static LazySingleton03 getInstance(){
        if(instance==null){
            synchronized (LazySingleton03.class){
                if(instance==null){
                    instance= new LazySingleton03();
                }
            }
        }
        return instance;
    }
}

优缺点:
1.多重检查是多线程开发中经常使用到的，如下代码所示，进行了两次if(instance==null)检查，就保证了线程安全。
2.这样，实例化代码只用执行一次，后面再次访问时，直接return 实例化对象，避免反复的方法同步。
3.线程安全，延迟加载，效率较高

• 结论：实际开发中，推荐使用这种方式

6.静态内部类

public class StaticInnerClass {

}
class Singleton01{
  private Singleton01(){}
  private static class Holder{
      private static Singleton01 instance = new Singleton01();
  }
  public static Singleton01 getInstance(){
      return Holder.instance;
  }

}

优缺点：
1.外部无法访问静态内部类Holder,只有当调用Singleton.getInstance方法时。才能得到单例对象
2.instance对象初始化的时机并不是在单例类Singleton被加载的时候， 而是在调用getInstance方法，使得静态内部类Holder被加载的时候。 因此这种实现方式是利用classloader的加载机制来实现懒加载，

• 并保证构建单例的线程安全。

7. 枚举实现单例模式

public class SingletoTest {
    public static void main(String[] args) {
        Singleton instance1 = Singleton.INSTANCE;
        Singleton instance2 = Singleton.INSTANCE;
        System.out.println(instance1==instance2);
    }
}
 enum Singleton{
    INSTANCE;//属性
    public void method(){
    }
 }

优缺点：借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题。 还能防止反射重新构建新的对象。