Java基础知识之设计模式--单例模式

Java设计模式--单例模式

声明：本文根据慕课网汤小洋老师的精品课程整理来的:慕课网

什么是设计模式（Design Pattern）？

　　设计模式是一套被反复使用，多数人知晓的，经过分类编目的，代码设计经验的总结。

什么情况下使用单例模式？

　　有些对象我们只需要一个，比如：配置文件，工具类，线程池，缓存，日志对象等，这种情况下我们要保证整个应用中某个实例有且仅有一个，如果创造出多个实例就会导致很多问题，比如：占用很多资源，结果不一致等。

单例模式的作用？

　　保证整个应用程序中某个实例有且仅有一个。

单例模式类型有几种？

　　1.饿汉模式

　　2.懒汉模式

单例模式之饿汉模式的实现方式？

　　1.将构造方法私有化，不允许外界直接构造对象。

　　2.创建类的唯一实例，使用private static修饰。

　　3.提供一个用于获取实例的方法，使用public static修饰。

　　特点：在加载的时候就产生实例对象。

 public class Singleton {
     //1.将构造方法私有化，不允许外界直接构造对象。
     private Singleton(){

     }
     //2.创建类的唯一实例,使用private static修饰
     private static Singleton instance = new Singleton();

     //3.提供一个用于获取实例的方法，使用public static修饰
     public static Singleton getInstance(){
         return instance;
     }
 }

　　多线程测试饿汉模式：

 /**
  * 多线程测试单例模式--饿汉模式
  * @author Administrator
  *
  */
 public class Test2 {

     public static void main(String[] args) {
         for (int i = 0; i < 20; i++) {
             new Thread(()->{
                 Singleton singleton = Singleton.getInstance();
                 System.out.println(singleton);
             }).start();
         }
     }

 }

　　测试结果：

单例模式之懒汉模式的实现方式？

　　1.将构造方法私有化，不允许外界直接构造对象。

　　2.声明类的唯一实例，使用private static修饰。

　　3.提供一个用于获取实例的方法，使用public static修饰。

 public class Singleton2 {

     //1.将构造方法私有化，不允许外边直接创建对象
     private Singleton2(){

     }
     //2.声明类的唯一实例，使用private static修饰
     private static Singleton2 instance;
     //3.提供一个用于获取实例的方法，使用public static修饰
     public static Singleton2 getInstance(){
         if(instance == null){
             instance = new Singleton2();
         }
         return instance;
     }
 }

饿汉模式和懒汉模式的区别？

　　饿汉模式的特点是：加载类时比较慢，因为在加载类时就创建对象，但运行时获取对象的速度比较快，因为对象已经创建好了，线程安全。

　　懒汉模式的特点是：加载类时比较快，因为在加载类时只是声明对象，但运行时获取对象的速度比较慢，因为要创建对象，线程不安全。

懒汉模式保证安全性的实现方法--DCL?

　　使用synchronized关键字修饰获取实例的方法代码块，在代码块中重新判断实例是否为空。

/**
 * 单例模式（懒汉模式）--使用DCL保证线程安全
 * DCL：double-check-locking
 * @author Administrator
 *
 */
public class Singleton3 {

    //1.将构造方法私有化，不允许外边直接创建对象
    private Singleton3(){

    }
    //2.声明类的唯一实例，使用private static修饰
    private static Singleton3 instance;
    //3.提供一个用于获取实例的方法，
    //使用synchronized关键字修饰获取实例的代码块,
    //并重新判断实例是否为空
    public static Singleton3 getInstance(){
        if(instance == null){
            synchronized(Singleton3.class){
                if(null == instance)
                    instance = new Singleton3();
            }
        }
        return instance;
    }
}

一种广泛的单例模式，结合饿汉模式和懒汉模式。

　　使用静态代码块的方式实现。

 /**
  * 通过静态代码块实现懒加载
  * 比较广泛的一种单例模式
  * @author Administrator
  *
  */
 public class SingletonHolder {
     private SingletonHolder(){

     }
     //在加载内部类的时候，instance不会实例化，之后当调用Holder.instance的时候，才会实例化SingletonHolder
     private static class Holder{
         private static SingletonHolder instance = new SingletonHolder();
     }

     public SingletonHolder getInstance(){
         return Holder.instance;
     }
 }

使用枚举类型作为内部类进行单例模式的实现：

 /**
  * 通过使用内部枚举类来进行实例化
  * @author Administrator
  *
  */
 public class SingletonEnum01 {
     //私有构造方法
     private SingletonEnum01(){

     }
     //构造内部枚举类，具有延迟加载的特性
     private enum EnumHolder{
         //声明的变量在加载的时候自动加载一次,类型为SingletonEnum
         INSTANCE;
         private SingletonEnum01 instance;
         EnumHolder(){
             this.instance = new SingletonEnum01();
         }
         //构造私有访问方法
         private SingletonEnum01 getInstance(){
             return instance;
         }
     }
     //创建静态外部访问方法
     public static SingletonEnum01 getInstance(){
         return EnumHolder.INSTANCE.getInstance();
     }
 }