单例模式

1.概述 　　单例模式用来保证系统中一个类只有一个实例且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。 　　 我的理解是：单例模式的实质就是私有化构造函数（保证只有一个实例）、析构函数（保证只有单例类能删除自己，防止其他类删除单例类造成悬浮引用）、拷贝构造函数（禁止类拷贝）、重载=操作符（禁止类赋值）。 2.常用的场景 　　单例模式常常与工厂模式结合使用，因为工厂只需要创建产品实例就可以了，在多线程的环境下也不会造成任何的冲突，因此只需要一个工厂实例就可以了。 3.全局变量和单例模式的比较 　　采用全局或者静态变量，会影响封装性，难以保证别的代码不会对全局变量造成影响。 　　全局变量可以提供单例模式实现的全局访问这个功能，但它不能保证应用程序只有一个实例。 4.代码及分析 1） 懒汉式单例模式 　　懒汉式是典型的时间换空间 。就是每次获取实例都会进行判断，看是否需要创建实例，浪费判断的时间。 1 class Singleton { 2 public: 3 static Singleton* getInstance(); 4 //析构的时候释放资源~ 5 ~Singleton() { 6 if( (_instance != NULL) 7 delete _instance; 8 } 9 protected: 10 Singleton(); 11 private: 12

单例模式 单例模式（Singleton Pattern） 是一种常用的软件设计模式，该模式的主要目的是确保 某一个类只有一个实例存在 。当你希望在整个系统中，某个类只能出现一个实例时，单例对象就能派上用场。 比如，某个服务器程序的配置信息存放在一个文件中，客户端通过一个 AppConfig 的类来读取配置文件的信息。如果在程序运行期间，有很多地方都需要使用配置文件的内容，也就是说，很多地方都需要创建 AppConfig 对象的实例，这就导致系统中存在多个 AppConfig 的实例对象，而这样会严重浪费内存资源，尤其是在配置文件内容很多的情况下。事实上，类似 AppConfig 这样的类，我们希望在程序运行期间只存在一个实例对象。 在 Python 中，我们可以用多种方法来实现单例模式： 使用模块 使用 __new__ 使用装饰器（decorator） 使用元类（metaclass） 使用模块 其实， Python 的模块就是天然的单例模式 ，因为模块在第一次导入时，会生成 .pyc 文件，当第二次导入时，就会直接加载 .pyc 文件，而不会再次执行模块代码。因此，我们只需把相关的函数和数据定义在一个模块中，就可以获得一个单例对象了。如果我们真的想要一个单例类，可以考虑这样做： # mysingleton.py class My_Singleton(object): def foo

单例模式 单例模式（Singleton Pattern） 是一种常用的软件设计模式，该模式的主要目的是确保 某一个类只有一个实例存在 。当你希望在整个系统中，某个类只能出现一个实例时，单例对象就能派上用场。 比如，某个服务器程序的配置信息存放在一个文件中，客户端通过一个 AppConfig 的类来读取配置文件的信息。如果在程序运行期间，有很多地方都需要使用配置文件的内容，也就是说，很多地方都需要创建 AppConfig 对象的实例，这就导致系统中存在多个 AppConfig 的实例对象，而这样会严重浪费内存资源，尤其是在配置文件内容很多的情况下。事实上，类似 AppConfig 这样的类，我们希望在程序运行期间只存在一个实例对象。 在 Python 中，我们可以用多种方法来实现单例模式 使用模块实现单例模式 其实， Python 的模块就是天然的单例模式 ，因为模块在第一次导入时，会生成 .pyc 文件，当第二次导入时，就会直接加载 .pyc 文件，而不会再次执行模块代码。因此，我们只需把相关的函数和数据定义在一个模块中，就可以获得一个单例对象了。如果我们真的想要一个单例类，可以考虑这样做： mysingleton.py class Singleton(object): def foo(self): pass singleton = Singleton() 将上面的代码保存在文件

单例模式（也叫单件模式）的作用就是保证在整个应用程序的生命周期中， 任何一个时刻，单例类的实例都只存在一个（当然也可以不存在）。 下面来看单例模式的结构图： 从上面的类图中可以看出单例模式的特点： 在单例类中有一个构造函数 Singleton ， 但是这个构造函数却是私有的 公开了一个 GetInstance（）方法 通过上面的类图不难看出单例模式的特点，从而也可以给出 单例模式的定义： 单例模式保证一个类仅有一个实例，同时这个类还必须提供一个访问该类的全局访问点。 1.最基本的单例： namespace Singleton { public class Singleton { //定义一个私有的静态全局变量来保存该类的唯一实例 private static Singleton singleton; /// <summary> /// 构造函数必须是私有的 /// 这样在外部便无法使用 new 来创建该类的实例 /// </summary> private Singleton() { } /// <summary> /// 定义一个全局访问点 /// 设置为静态方法 /// 则在类的外部便无需实例化就可以调用该方法 /// </summary> /// <returns></returns> public static Singleton GetInstance() { /

单例模式 一个类只允许创建唯一的对象 禁止在类的外部创建对象：私有化构造函数：private或protected 类的内部维护唯一对象：静态成员变量 提供访问单例对象的方法：静态成员函数，返回在类内部唯一构造的实例 创建方式 饿汉式：单例对象无论用或不用，程序启动即创建。 懒汉式：单例对象在用的时候再创建，不用即销毁。 一： #include <iostream> using namespace std; class Singleton { public: static Singleton *GetInstance() { if (m_Instance == NULL ) { m_Instance = new Singleton (); } return m_Instance; } static void DestoryInstance() { if (m_Instance != NULL ) { delete m_Instance; m_Instance = NULL ; } } // This is just a operation example int GetTest() { return m_Test; } private: Singleton() { m_Test = 10; } static Singleton *m_Instance; int m_Test; };

单例模式（ Singleton Pattern） 使用场景： 独一无二 确保一个类在任何情况下都绝对只有一个实例，并只提供一个全局访问点。 优缺点 优：保证内存中只有一个实例，减少了内存开销，避免对资源的过多占用。 类图： 略 源码实例： ServletContext、ServletContextConfig、在 Spring 框架应用中 ApplicationContext、数据库连接池。 使用建议： 建议使用内部类创建单例模式、兼顾性能与线程安全。 实现方式（4种）： （一）懒汉式： 优点：使用时创建实例、不浪费内存空间 缺点：部分实现方式线程不安全、通过加锁虽保证线程安全但影响性能。 package com.knowledge.system.software_design_pattern.singleton_pattern.course_instance.lazy_singleton; /** * @program: demo-pom * @description: 懒汉式 * @author: bo.hu * @create: 2020-01-19 16:32 **/ public class LazySingleton<Syncchronized> { private static LazySingleton lazySingleton=null; private

单例模式指的是一个类只能产生一个实例化对象 如果希望只能产生一个实例化对象 那么需要将这个类保持一个相对封闭状态即使用一个私有的无参构造方法覆盖默认的无参构造方法 然而此时因为private修饰 构造方法不能调用 所以想到一个方法就是在类中优先实例化对象 因此实例化对象此时就是一个类中普通属性 使用static关键字修饰就可以实现需求 然后使用private修饰属性 getter()方法完善 此时就实现了单例模式 饿汉式方法:从一开始就创建好对象 package com.bite.angda; class Singleton{ private static final Singleton singleton=new Singleton(); private void Singleton(){}; public static Singleton getSingleton(){ return singleton; } public void print(){ System.out.println("hello"); } } public class Angdalove{ public static void main(String[] args){ Singleton singleton=Singleton.getSingleton(); singleton.print(); } }

1.饿汉式（线程安全） 1.创建私有的静态的final修饰的常量，静态的，在类加载机制的（加载， 连接，初始化 ，使用，卸载）步骤中的连接中的（验证， 准备 ，解析）中的准备阶段就会给 静态变量分配内存空间 ，但这个时候是 默认值 ，初始值是在 初始化 过程中， 新建该类对象 。 private static final 类 INSTANCE = new 类（）； 2.构造方法私有，如果我们不写，默认是无参，我们需该权限为private private 类 ( ) { } 3.提供获取对象方法,这样，外部就只能通过getInstance方法获取对象，并且这个对象是final修饰的。 public 类 getInstance ( ) { return INSTANCE ; } 这个时候有人提出来了，假如我不用这个对象，那在类加载的时候依然分配内存空间，岂不是空间浪费呢？其实我想说的是，你不用它，初始化它干啥？类只有在 首次+主动使用 （主动使用： 反射，创建该类对象，调用该类静态方法或静态变量，初始化该类子类等等 ）才会触发初始化。不过为了解决这个问题，仍然有方案，请跟我来~~~~~~ 2.懒汉式（线程不安全，在多线程下会new出多个对象，违背了单例原则，加锁） public class 类 { /*volatile关键字，JMM 修饰变量是变量的值在主内存里改变，主内存会告诉cpu

饱汉模式 //lazy class LazyPerson { private static volatile LazyPerson person ; private LazyPerson ( ) { } public static LazyPerson getSingleton ( ) { if ( person == null ) { synchronized ( LazyPerson . class ) { if ( person == null ) { person = new LazyPerson ( ) ; } } } return person ; } } 饿汉模式 //hungry class HungryPerson { private HungryPerson ( ) { } private static HungryPerson hungryPerson = new HungryPerson ( ) ; public static HungryPerson getHungryPerson ( ) { return hungryPerson ; } } 饱汉模式利用Java的类加载机制保证线程安全，而饿汉模式则需要使用volatile和synchronized以及双重检查机制来保证线程安全。 测试代码 public static void main (

（三）单例模式（Singleton Pattern） 1.单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。 注意： 1）.单例类只能有一个实例。 2）.单例类必须自己创建自己的唯一实例。 3）.单例类必须给所有的其他对对象提供这一实例。 2.作用：保证一个类仅有一个实例，并提供一个访问它的全局访问点。 3. 应用实例： 1、一个党只能有一个主席。 2、Windows 是多进程多线程的，在操作一个文件的时候，就不可避免地出现多个进程或线程同时操作一个文件的现象，所以所有文件的处理必须通过唯一的实例来进行。 3、一些设备管理器常常设计为单例模式，比如一个电脑有两台打印机，在输出的时候就要处理不能两台打印机打印同一个文件。 优点： 1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。 2、避免对资源的多重占用（比如写文件操作）。 缺点： 没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。 4. 实现 我们将创建一个 SingleObject