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