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

时间：2022-04-18 16:41:41

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();

         }

     }

 }

　　测试结果：

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

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

　　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();

     }

 }

相关文章