【经典设计模式】一、单例设计模式

class Singleton{
    
    // 1、构造器私有化，外部不能new
    private Singleton(){}

    // 2、本类内部创建实例对象
    private final static Singleton instance = new Singleton();

    // 3、通过一个静态方法为外部提供一个获得此类对象的方法
    public static Singleton getInstance(){
        return instance;
    }
}

4、饿汉式（静态常量）优缺点

优点：这种写法比较简单，在类加载的时候就完成了实例化，避免了线程了同步问题。

缺点：在类装载的时候就完成了实例化。如果刚开始就没使用过这个实例就会造成内存的浪费。

结论：这种单例模式可用，但是使用不当会造成内存的浪费。

② 饿汉式（静态代码块）

饿汉式（静态代码块）：在类中创建对象的引用，将创建对象的事情放到static代码块里面执行。static代码块随着类的加载而加载的。

1、创建步骤如下：

（1）构造器私有化（防止new）

（2）类的内部创建本类的引用

（3）在static静态代码块中创建类的实例。

（4）向外部暴露一个静态的公共方法，这个公共方法的作用就是向外界提供该类的实例

（5）代码实现

2、代码实现：

class Singleton{

    // 私有化 构造器
    private Singleton(){}

    private static Singleton instance;

    // 创建类的实例对象
    static{
        instance = new Singletoon();
    }
    
    // 静态方法供外部调用获取实例
    public static Singleton getInstance(){
        return instance;
    }
}

3、饿汉式（静态代码块）优缺点

这种方式实际上是把类的创建过程放到了static代码块中，缺点是类不创建对象的时候，会浪费空间。

③ 懒汉式（线程不安全）

所谓懒汉式就是等待外部调用的时候，再根据需要创建对象。

1、创建步骤如下：

（1）构造器私有化（防止new）

（2）类的内部创建本类的引用

（3）向外部暴露一个静态的公共方法，这个公共方法的作用就是向外界提供该类的实例，先判断该对象是否为空，为空的话就创建对象

（4）代码实现

2、代码实现：

class Singleton{

    // 私有化 构造器
    private Singleton(){}

    private static Singleton instance;

   
    // 首先判断是否为空，静态方法供外部调用获取实例
    public static Singleton getInstance(){
        if(instance == null){
            instance = new Singeton();
        }
        return instance;
    }
}

3、优缺点

起到了懒加载的效果，但是只能在单线程的情况下使用。

如果在多线程的情况下，一个线程进入if(instance == null)判断语句块，还未来得及往下执行，另一个线程也通过判断这个语句，这时会产生多个实例。所以多线程的情况下是不安全的。

在开发中，不要使用这种模式。

④ 懒汉式（线程安全，同步方法）

所谓懒汉式就是等待外部调用的时候，再根据需要创建对象。通过同步方法控制线程的执行，保证安全。

1、创建步骤如下：

（1）构造器私有化（防止new）

（2）类的内部创建本类的引用

（3）向外部暴露一个静态的公共方法，在公共方法的前面添加synchronized来控制线程的执行，这个公共方法的作用就是向外界提供该类的实例，先判断该对象是否为空，为空的话就创建对象

（4）代码实现

2、代码实现：

class Singleton{

    // 私有化 构造器
    private Singleton(){}

    private static Singleton instance;

   
    // 首先判断是否为空，静态方法供外部调用获取实例
    public static synchronized Singleton getInstance(){
        if(instance == null){
            instance = new Singeton();
        }
        return instance;
    }
}

3、优缺点

解决了线程不安全的问题，但是效率太低了，每个类想获得类的实例的时候，必须执行getInstance（）都要执行同步，虽然new对象只需要执行一次。但是方法同步执行效率太低。

所以在实际开发中，不推荐使用这种方式。

⑤ 懒汉式（线程安全，同步代码块）

所谓懒汉式就是等待外部调用的时候，再根据需要创建对象。通过同步方法控制线程的执行，保证安全。

1、创建步骤如下：

（1）构造器私有化（防止new）

（2）类的内部创建本类的引用

（3）向外部暴露一个静态的公共方法，在公共方法的中添加synchronized同步代码块来控制线程的执行

（4）代码实现

2、代码实现：

class Singleton{

    // 私有化 构造器
    private Singleton(){}

    private static Singleton instance;

   
    // 首先判断是否为空，静态方法供外部调用获取实例
    public static Singleton getInstance(){
        if(instance == null){
            synchronized (Singleton.class){
                instance = new Singeton();
            }
        }
        return instance;
    }
}

3、优缺点

这种方式并不能起到线程同步的作用，因为当if(instance == null)的时候，一个线程已经执行了，还未来得及往下执行，另一个线程又通过这个判断语句，这时候会产生多个实例，第一个实例没有更新到内存中。实际开发中不能使用这种方式。

⑥ 双重检查，修饰类的时候是volatile

所谓双重检查就是为了防止多次创建实例的情况，是保证线程安全和提高效率

1、创建步骤如下：

（1）构造器私有化（防止new）

（2）类的内部创建本类的引用

（3）向外部暴露一个静态的公共方法，在公共方法的中有两层if，第一层if是判断是否有对象创建，没有的话就创建，当有AB两个线程同时进入第一层if，A先创建对象，此时singleton有对象了。B线程再进去，第二层if判断已经有对象了，就不会再去创建。假如C线程再来的话，第一层判断对象已经存在，那么就返回对象。保证了线程的安全性提高了执行的效率。

（4）知识补充：

volatile：当修饰类的对象应用的时候，呈现出所有线程都可以看到的共享内存的最新状态。

2、代码实现：

class Singleton{

    // 私有化 构造器
    private Singleton(){}

    private static volatile Singleton instance;

   
    // 首先判断是否为空，静态方法供外部调用获取实例
    public static Singleton getInstance(){
        if(instance == null){
            synchronized (Singleton.class){
                if(instance == null){
                    instance = new Singeton();
                }
            }
        }
        return instance;
    }
}

⑦ 静态内部类

所谓内部静态类，通过内部静态类创建静态常量对象。直接返回内部类对象

1、创建步骤如下：

（1）构造器私有化（防止new）

（2）创建内部静态类，并且创建静态常量对象引用

（3）返回内部类对象

2、代码实现：

class Singleton{

    // 私有化 构造器
    private Singleton(){}

    // 内部类创建外部类静态常量对象
    private static class SingletonInstance{
        private static final Singleton INSTANCE= new Singleton();
    }
    
   
    // 返回外部类对象
    public static Singleton getInstance(){
        
        return SingletonInstance.INSTANCE;
    }
}

3、结论

当外部类被加载的时候，内部类不会被加载。当执行获取对象的静态方法的时候，内部类才会被加载，只会被加载一次。

这种方式，实时的只会限制一个线程的执行。

⑧ 枚举

所谓枚举，就是通过调用枚举类的成员来限制线程的单例。

1、创建步骤如下：

（1）创建枚举类，添加枚举类属性，且属性唯一。

（2）外部通过枚举类名调用枚举类的属性，获取实例对象。

2、代码实现：

public class Singleton1 {
    public static void main(String[] args) {
        Singleton singleton = Singleton.INSTANCE;
        Singleton singleton2 = Singleton.INSTANCE;

        System.out.println(singleton == singleton2);

        System.out.println(singleton.hashCode());
        System.out.println(singleton2.hashCode());
    }
}

enum Singleton{
    INSTANCE;
    public void say(){
        System.out.println("OK");
    }
}

3、结论

不仅能避免多线程同步的问题，而且还能防止反序列化重新创建新的对象。

4、单例模式总结

单例模式保证了系统内存中只存在一个对象，节省了系统的资源，对于一些需要频繁销毁的对象，使用单例模式可以提高系统的性能。

当想实例化一个单例的时候，必须调用创建实例的方法。

单例模式使用场景：

需要频繁创建和销毁对象、创建对象的时候耗时过多或者是耗费资源过多，经常用到的工具类对象、频繁访问数据库对象。

推荐使用：

枚举、静态内部类、双重检查

如果这篇文章能让你系统认识单例设计模式，求个赞！

晓风残月一望关河萧索

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【经典设计模式】一、单例设计模式

1、前言设计模式是程序员在面对同类软件工程设计问题所总结出来的有用的经验，模式不是代码，而是某类问题的通用解决方案。设计模式代表了最佳的实践。这些解决方案是众多软件开发人员经过相当长的一段时间的经验和错误总结出来的。设计模式的本质就是提高软件的维护性，通用性和扩展性，并降低软件的复杂度。简单的说，就是前辈们在遇到一些问题和经验总结出来的，面对不同的问题，有不同的解决方案，且对症下药。使问题解决，效率提高，提高了程序的安全性、健壮性、可靠性等。2、设计模式类型 ...
复制链接

扫一扫