Java十分钟快速掌握单例模式

目录

• 前言
• 1、什么是单例模式：
• 2、单例模式的优缺点：
• 3、懒汉模式（比较常用）
• 4、饿汉模式【推荐使用】
• 5、单例模式的应用场景
• 6、单例模式的应用实例
• 小结:

前言

首先在Java中有23种设计模式：

创建型模式：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式

结构型模式：适配器模式、装饰者模式、代理模式、外观模式、桥接模式、组合模式、享元模式

行为型模式：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

1、什么是单例模式：

定义：

指一个类只有一个实例，且该类能自行创建这个实例的一种模式。可以避免因打开多个任务管理器窗口而造成内存资源的浪费，或出现各个窗口显示内容的不一致等错误。比如咱们电脑是不是只能打开一个任务管理器？对吧，这就是为了防止资源浪费和其他错误。

项目中一般可以通过单例模式来获取同一个对象来调用工具方法，这样的好处是节约内存资源，我没有必要创建多个不同的对象，因为这样消耗内存资源

简而言之： 单例就是程序只有一个实例，该类负责创建自己的对象，同时要确保只有一个对象创建

单例模式的特点：

• 构造器私有
• 持有自己类型的属性
• 对外提供获取实例的静态方法

单例模式的结构图：

2、单例模式的优缺点：

优点：

• 减少了内存的开销
• 避免对资源的多重占用
• 设置全局访问点，可以优化和共享资源的访问

缺点（参考自互联网）：

• 一般没有接口，扩展困难。如果要扩展，则除了修改原来的代码，没有第二种途径，违背开闭原则
• 在并发测试中，单例模式不利于代码调试。在调试过程中，如果单例中的代码没有执行完，也不能模拟生成一个新的对象
• 单例模式的功能代码通常写在一个类中，如果功能设计不合理，则很容易违背单一职责原则

看一张单例模式的思维导图：

3、懒汉模式（比较常用）

懒汉模式特征是延迟初始化,在调用方法获取实例的时候才会实例化对象 线程不安全，严格意义上来说不是单例模式，优势是在获取实例才会创建对象因此更节省内存开销

Demo：

public class SingLeton {

    //1、有自己类型的属性
    private static SingLeton instance;

    //2、构造器私有化
    private SingLeton(){}

    //3、对外提供获取实例的静态方法
    public static SingLeton getInstance(){
        if (instance == null){
            instance = new SingLeton();
        }
        return instance;
    }

}

测试类：

public class Test {
    public static void main(String[] args) {

        //判断是否产生的是同一个对象
        SingLeton s1 = SingLeton.getInstance();
        SingLeton s2 = SingLeton.getInstance();
        System.out.println(s1 == s2);
    }
}

输出：

true

注意

关于懒汉模式线程非安全

现在知道懒汉模式的线程是非安全的，那么就需要使用锁（synchronized ）来同步：

/**
 *   保证 instance 在所有线程中同步
 */
public class SingLeton2 {

        //1、有自己类型的属性
        private static volatile SingLeton2 instance ;    
        
        //2、构造器私有化
        private SingLeton2() {
        }

        public static synchronized SingLeton2 getInstance() {
            //getInstance 方法前加同步
            if (instance == null) {
                instance = new SingLeton2();
            }
            return instance;
        }
    }

如果是写多线程，则不要删除上例代码中的关键字 volatile 和 synchronized，否则将存在线程非安全的问题。如果不删除这两个关键字就能保证线程安全，但是每次访问时都要同步，会影响性能，且消耗更多的资源，这是懒汉式单例的缺点。

4、饿汉模式【推荐使用】

饿汉模式线程安全，常用，但是容易产生垃圾对象，因为饿汉模式一开始加载类的时候就初始化 了实例

Demo:

/**
 *
 * 饿汉模式
 */
public class SingLeton {

    //持有自己类型的属性   (和懒汉一样)
    //由于static修饰，只在类加载的时候执行一次，类加载的时候就实例化对象
    private static SingLeton instance = new SingLeton();

    //构造器私有化，不能通过它创建对象
    private SingLeton(){};

    //对外提供获取实例的静态方法
    public static SingLeton getInstance(){
        return instance;
    }
}

测试类：

public class Test {
    public static void main(String[] args) {

        //判断是否产生的是同一个对象
        SingLeton s1 = SingLeton.getInstance();
        SingLeton s2 = SingLeton.getInstance();
        System.out.println(s1 == s2);
    }
}

输出：

true

懒汉模式和饿汉模式对比：

• 懒汉模式延迟加载，非线程安全，饿汉模式线程安全
• 懒汉模式刚运行不实例化对象，需要的时候才实例化对象，相当于来讲更节省内存开销
• 饿汉模式只要运行都会加载类的时候就给你初始化了，就需要使用更大的内存

图解：

5、单例模式的应用场景

• 需要经常创建的一些类，使用单例可以降低系统的内存压力
• 这个类只要求生成一个对象的时候，比如每个人的名字
• 类创建实例时占用资源较多，或实例化耗时较长，且经常使用
• 频繁访问数据库或文件的对象
• 类需要频繁实例化，而创建的对象又频繁被销毁的时候，如多线程的线程池

6、单例模式的应用实例

这里使用懒汉式单例模式模拟产生班级的班长 分析： 在每一个学期内，班级的班长只有一人，所以适合用单例模式实现

Person类：

/**
 * 使用懒汉模式
 */

public class Person {

    //保证instance在所有线程中同步
    private static volatile Person instance;

    private Person(){
        System.out.println("产生一个班长");
    }

    //加上synchronized锁
    public static synchronized Person getInstance(){
        if(instance == null){
            instance = new Person();
        }else {
            System.out.println("错误信息：已经有一个班长，不能再产生");
        }
        return instance;
    }

    public void getName(){
        System.out.println("我是班长：小强");
    }
}

测试类：

public class Test {
    public static void main(String[] args) {

        Person p1 = Person.getInstance();
        p1.getName(); //输出班长名字

        Person p2 = Person.getInstance();
        p2.getName();

        if(p1 == p2){
            System.out.println("两个班长是同一个人");
        }else {
            System.out.println("两个班长是同一个人");

        }
    }
}

运行结果：

产生一个班长
我是班长：小强
错误信息：已经有一个班长，不能再产生
我是班长：小强
两个班长是同一个人

小结:

这个就是单例模式，当程序已经产生一个对象后，就不会产生一个新的对象，即使有多个对象也是同一个对象而已，在使用懒汉模式的时候需要注意线程安全问题，在平时更加推荐使用饿汉模式，也需要注意资源的占用。

到此这篇关于Java十分钟快速掌握单例模式的文章就介绍到这了,更多相关Java 单例模式内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！