软件设计模式之路-----单例模式

单例模式在面试中是一个高频面试题，需要多了解一点他的特性。

在系统中，为了节省内存资源、保存数据一致，对某些类只能创建一个实例，这就是单例模式

单例模式定义：指一个类只有一个实例，且该类能自行创建这个实例。

j2ee标准中的ServletContext和ServletContextConfig、Spring框架中的ApplicationContext都是单例模式。

单例模式的特点：

1. 单例模式只有一个实例对象
2. 该实例对象必须由该单例自行创建
3. 单例类对外提供一个访问该实例的全局访问点

单例模式的优点：

• 单例模式可以保证在系统中只有一个实例，减少了内存开销
• 可以避免对资源的多重占用
• 单例模式设置了全局访问点，可以优化和共享资源的访问

单例模式的缺点：

• 单例模式一般没有接口，扩展时需要修改原码，违背了开闭原则
• 在并发测试中，不利于代码调试。
• 单例模式的功能写在一个类中，如果功能设计的不合理，则很容易违背单一原则

单例模式的应用场景：

• 需要频繁创建的类，
• 某类只要求生成一个对象的时候，例如：一个国家的主席，一个人的老婆
• 某些类创建实例时占用资源比较多，且经常使用
• 某类需要频繁实例化，且创建的对象又频繁被销毁的时候，如线程池、网络连接池。
• 频繁访问数据库或文件的对象
• 需要被共享的对象，如Web中的配置对象，数据库的连接池

单例模式的结构：

主要角色如下：

1、单例类：包含一个实例且能自行创建该实例

2、访问类：使用该单例的类

单例模式的实现：

单例模式的使用比较简单，方法也有多种，实现规则：

1. 将构造函数设有私有，外部类就无法创建实例
2. 定义一个静态私有实例
3. 向外提供一个静态的公有函数，用于获取或创建静态私有实例

两种实现形式：

第一种：饿汉式单例----只有在用到时才创建该单例

package com.wly.DesignPatterns;
/**
 * @program: StudyDome
 * @author: yuanzhang
 * @create: 2020-11-25 16:42
 **/
public class LazySingleton {
    private static volatile LazySingleton instance=null;
    //保证 instance 在所有线程中同步
    private LazySingleton(){}
    //private 避免类在外部被实例化
    public static synchronized LazySingleton getInstance(){
        //getInstance 方法前加同步
        if(instance==null){
            instance=new LazySingleton();
        }
        return instance;
    }
}

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

第二种饿汉式单例：一加载时就创建单例

package com.wly.DesignPatterns;
/**
 * @program: StudyDome
 * @author: yuanzhang
 * @create: 2020-11-25 16:47
 **/
public class HungrySingleton {
    private static final HungrySingleton instance=new HungrySingleton();
    private HungrySingleton(){}
    public static HungrySingleton getInstance(){
        return instance;
    }
}

应用场景：使用懒汉模式创建一个总统类

package com.wly.DesignPatterns;
/**
 * @program: StudyDome
 * @author: yuanzhang
 * @create: 2020-11-25 16:51
 **/
public class SingletionPresident {
    public static void main(String[] args) {
        President president1 = President.getPresident();
        President president2 = President.getPresident();
        if (president1==president2){
            System.out.println("只有一个总统");
        }else {
            System.out.println("他们是两个总统");
        }

    }
}
class President{
    private static volatile President president=null;
    private President(){}
    public static synchronized President getPresident(){
        if (president==null){
            president = new President();
        }
        return president;
    }
}

输出：

只有一个总统

应用场景：使用饿汉模式创建一个妻子类

package com.wly.DesignPatterns;
/**
 * @program: StudyDome
 * @author: yuanzhang
 * @create: 2020-11-25 17:00
 **/
public class SingletonWife {
    public static void main(String[] args) {
        Wife wife1 = Wife.getWife();
        Wife wife2 = Wife.getWife();
        if (wife1==wife2){
            System.out.println("他只有一个老婆");
        }else {
            System.out.println("他有两个老婆！！！呸！渣男");
        }
    }
}
class Wife{
    private static Wife wife = new Wife();
    private Wife(){}
    public static Wife getWife(){
        return wife;
    }
}

输出

他只有一个老婆

单例模式的扩展：

单例模式可以扩展为有限的多例模式，就是设定系统中能存在多少个这样的单例。生成多个单例存到ArrayList中，很简单实现就不累述了。