05.单例模式

谁践踏了优雅 2023-10-05 21:11 44阅读 0赞

## 场景 ##

1.  随着网店的盈利，peter又在自己家楼下开了一家实体店。开业之后peter想做一个小调查，每周什么时候的人流量最多，什么时候最少，让店员用本子轮流统计，但是由于顾客是流动的，一会出一会进，肯定是不准确的。还有多个店员轮流统计那就可能会有多个记录本。

![在这里插入图片描述][20210306145722404.png]

1.  于是就在店门出设一个计数台，保证只有一个记录本，进去一个就+1，出去一个就-1。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ3NzUzMQ_size_16_color_FFFFFF_t_70]

## 单例模式模式 ##

### 定义 ###

> 指一个类只有一个实例，且该类能自行创建这个实例的一种模式。

即保证一个类仅有一个实例，并提供一个访问它的全局访问点

*  为防止实例实创建多个，将构造函数限制为private。
 *  建一个类静态变量，持有一个自己的实例。
 *  通过静态方式对外部提供这一实例。
 *  对静态实例的初始化，有两种方式：饿汉式和懒汉式

### 结构 ###

*  单例类：包含一个实例且能自行创建这个实例的类。
 *  访问类：使用单例的类。

### UML类图 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ3NzUzMQ_size_16_color_FFFFFF_t_70 1]

### 代码实现 ###

#### 饿汉模式 ####

在静态变量里，直接初始化实例

public class HungrySingleton {
    
        private static HungrySingleton instance = new HungrySingleton();
    
        private HungrySingleton() {
        }
    
        public static HungrySingleton getInstance() {
            return instance;
        }
    }

#### 懒汉模式 ####

*  在静态变量里，只声明变量
 *  在第一次获取实例的请求getInstance()到来时，才创建实例
 *  懒汉模式线程是不安全的

/**
     * 双重校验锁实现线程安全
     */
    public class LazySingleton {
    
        private static volatile LazySingleton instance;//保证 instance 在所有线程中同步
    
        private LazySingleton() {
        }
    
        public static LazySingleton getInstance() {
            if (instance == null) {
                synchronized (LazySingleton.class) {
                    if (instance == null) {//双重校验锁
                        instance = new LazySingleton();
                    }
                }
            }
            return instance;
        }
    }
    
    -------------------------------------------------------------------------------
    
    /**
     * Lazy initialization holder class 延迟加载
     */
    public class Singleton {
        /**
         * 类级内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例
         * 没有绑定关系，而且只有被调用的时候才会装载，从而实现了延迟加载
         */
        private static class SingletonHolder {
            /**
             * 静态初始化器，由JVM来保证线程安全
             */
            public final static Singleton instance = new Singleton();
        }
    
        public static Singleton getInstance() {
            return SingletonHolder.instance;
        }
    }

#### 实现 ####

public class SessionCount {
    
        private AtomicInteger count = new AtomicInteger(0);
    
        private static volatile SessionCount instance;//懒汉式
    
        private SessionCount() {
        }
    
        //获取唯一可用的对象
        //懒汉式
        public static SessionCount getInstance() {
            if (instance == null) {//双重校验锁
                synchronized (SessionCount.class) {
                    if (instance == null) {
                        instance = new SessionCount();
                    }
                }
            }
    
            return instance;
        }
    
        /***以下是业务方法***/
        public int plus() {
            return count.incrementAndGet();
        }
    
        public int decrease() {
            return count.decrementAndGet();
        }
    
        public void showMessage() {
            System.out.println("当前人数：" + this.count.get());
        }
    }

#### 客户端调用 ####

public class TestClient {
    
        public static void main(String[] args) {
            //营业开门
            SessionCount count = SessionCount.getInstance();
            count.plus();
            count.showMessage();
    
            SessionCount count1 = SessionCount.getInstance();
            count1.plus();
            count1.showMessage();
    
            //出去一个
            SessionCount count2 = SessionCount.getInstance();
            count2.decrease();
            count2.showMessage();
        }
    }

#### 结果 ####

当前人数：1
    当前人数：2
    当前人数：1

## 优缺点 ##

*  **时间和空间**
    
     *  **懒汉式是典型的时间换空间**，也就是每次获取实例都会进行判断，看是否需要创建实例，浪费判断时间。
     *  **饿汉式是典型的空间换时间**，当类装载的时候就会创建类实例，不管你用不用，都会创建出来。每次调用的时候就不需要再次判断，节约了运行时间。

## 单例模式的本质 ##

单例模式的本质：控制实例数目

## 使用场景 ##

*  在应用场景中，某类只要求生成一个对象的时候，如一个班中的班长、每个人的身份证号等。
 *  当对象需要被共享的场合。由于单例模式只允许创建一个对象，共享该对象可以节省内存，并加快对象访问速度。如 Web 中的配置对象、数据库的连接池等。
 *  当某类需要频繁实例化，而创建的对象又频繁被销毁的时候，如多线程的线程池、网络连接池等。

[20210306145722404.png]: https://img-blog.csdnimg.cn/20210306145722404.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ3NzUzMQ_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20210306145736438.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ3NzUzMQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ3NzUzMQ_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20210306145755384.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ3NzUzMQ==,size_16,color_FFFFFF,t_70