单例模式

写在前面 设计模式是基于固定设计场景的一套解决方案，目的是为了完成开闭原则，或者说面向后续的需求变更，以成本最低的改动和测试完成新功能。同时设计模式也是一种程序员之间的交流语言，可以省去很多沟通成本。 在工作的过程中，从最初不知如何使用设计模式，到中间刻意使用设计模式，到今天稍有好转的正确的使用设计模式，踩了许多坑，也有过度设计的时候，为了避免今后在犯同样的错误，所以准备将自己在项目实践的过程中使用过的设计模式记录下来。 设计模式中，有一些实战里用过，有的没用过，没用过的应该是对这个设计方法没有领悟透彻，所以不知道该怎么用。 目前先按照自己的理解记录下来，有更深的领悟会更新。 创建型设计模式 1、工厂方法模式(FactoryMethod) 工厂方法模式的实质是“定义一个创建对象的接口，但让实现这个接口的类来决定实例化哪个类。工厂方法让类的实例化推迟到子类中进行。” 工厂方法模式，是在抽象类中定义创建对象的方法，调用声明创建过程（抽象方法，但创建对象的过程的实现是在实现类中定义。 也就是说，在创建对象时，创建步骤是固定的，但各个步骤的实现是多种多样的，这种情况下可以使用工厂方法。 例如：创建一个电脑主机，需要安装CPU，内存，硬盘，显卡。这个安装步骤是固定的，但是由不同的工厂实现类去实现这几个步骤。 这种父类声明，子类实现的方式有很多，把这种方法用于创建对象，就叫工厂方法

1. 单例模式 什么是单例模式？简言之就是确保定义为单例模式的类在程序中有且只有一个实例。单例模式的特点： 只有一个实例 （只能有一个对象被创建） 自我实例化（类构造器私有） 对外提供获取实例的静态方法 2.单例模式的实现 常见的单例模式实现方式有五种： 2.1. 懒汉式 懒汉式（一般也称之为 饱汉式），具体代码实现如下： public class Singleton { /** * 自我实例化 */ private static Singleton singleton; /** * 构造方法私有 */ private Singleton() { System.out.println("创建单例实例..."); } /** * 对外提供获取实例的静态方法 */ public static Singleton getInstance() { if (null == singleton) { singleton = new Singleton(); } return singleton; } } 从代码实现中可以看到，实例并不是在一开始就是初始化的，而是在调用 **getInstance()**方法后才会产生单例，这种模式延迟初始化实例，但它并非是线程安全的。 public class SingleTonTest { /** * 多线程模式下测试懒汉模式是否线程安全 * *

请参考　　https://blog.csdn.net/javazejian/article/details/71333103 以单例模式来说，最普通的是饿汉式，这种模式在类被加载时就会创建该单例所需要的全部资源，比较耗时间。 懒汉式在多线程访问情况下可能会出现多次创建对象的情况，需要做同步处理 public class Singleton { private static volatile Singleton singleton=null; private Singleton(){} public static Singleton getInstance(){ if(singleton==null){ synchronized (Singleton.class){ if(singleton==null){ singleton=new Singleton(); } } } return singleton; } } 使用双重检查锁的方式。volatile关键字的语义 该关键字有两层语义。第一层语义是可见性，可见性是指在一个线程中对该变量的修改会马上由工作内存（Work Memory）写回主内存（Main Memory），所以其它线程会马上读取到已修改的值，关于工作内存和主内存可简单理解为高速缓存（直接与CPU打交道）和主存（日常所说的内存条），注意工作内存是线程独享的

　　单例模式也称为单件模式、单子模式，可能是使用最广泛的设计模式。其意图是保证一个类仅有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。有很多地方需要这样的功能模块，如系统的日志输出，GUI应用必须是单鼠标，MODEM的联接需要一条且只需要一条电话线，操作系统只能有一个窗口管理器，一台PC连一个键盘。 单例模式有许多种实现方法，在C++中，甚至可以直接用一个全局变量做到这一点，但这样的代码显的很不优雅。 使用全局对象能够保证方便地访问实例，但是不能保证只声明一个对象——也就是说除了一个全局实例外，仍然能创建相同类的本地实例。 1. 懒汉式 /////////// lazy 非线程安全 //////////////// class CSingleton { private: CSingleton(){} //构造函数是私有的 // 最好将 copy construct 和 assignment 为空且私有化 static CSingleton* m_pInstance; public: static CSingleton* GetInstance() { if (m_pInstance == 0) //判断是否第一次调用 m_pInstance = new CSingleton(); return m_pInstance; } }; CSingleton*

1、饿汉式 在类加载的时候完成 类的初始化。 　　　　1.1 静态代码块 获取 对象 　　　　1.2 直接 new 一个对象 结论 可以用 可能会造成 内存的 浪费 （这个类 可能会被别的方式 初始化 比如 子类 被初始化 通过反射，或者调用 这个类的静态方法） 2、懒汉式 　　　　在使用 获取对象的方法时返回一个对象。线程不安全。 开发时不用 　　　　在使用 获取对象的方法时可以加个同步的 synchronized 解决线程安全 问题 效率太低 不使用。 3、双重锁模式 　　　　判断 对象是不是空 是空的化 进入一个同步方法 方法里面 由判断了下 对象 是空就 new 对象 是推荐使用的。解决线程安全问题 和 实现懒加载。 4、静态内部类的方式 　　　　推荐使用 外部类加载的时候内部类不一定加载 只有在使用到内部类的时候才加载 jvm加载类 是线程安全的。解决线程安全问题，和实现懒加载。 5、枚举类的方式获取对象 　　　　推荐使用 解决线程安全问题 代码如下 public enum Singleton { 　　INSTANCE; 　　public void sayHello(){ 　　　　System.out.println("ok"); 　　} } public class Test { 　　public static void main(String[] args) { 　　

单例模式看起来简单，但是需要考虑的问题却很多。 保证一个类仅有一个实例，并提供一个该实例的全局访问点。——《设计模式》 在软件系统中，经常有这样一些特殊的类，必须保证他们在系统中只存在一个实例，才能确保它们的逻辑正确性、以及良好的效率。 所以得考虑如何绕过常规的构造器（不允许使用者new出一个对象），提供一种机制来保证一个类只有一个实例。 应用场景： Windows的Task Manager（任务管理器）就是很典型的单例模式，你不能同时打开两个任务管理器。Windows的回收站也是同理。 应用程序的日志应用，一般都可以用单例模式实现，只能有一个实例去操作文件。 读取配置文件，读取的配置项是公有的，一个地方读取了所有地方都能用，没有必要所有的地方都能读取一遍配置。 数据库连接池，多线程的线程池。 实现: 1、饿汉式(线程安全，调用效率高，但是不能延时加载)： public class ImageLoader{ private static ImageLoader instance = new ImageLoader; private ImageLoader(){} public static ImageLoader getInstance(){ return instance; } } 一上来就把单例对象创建出来了，要用的时候直接返回即可，这种可以说是单例模式中最简单的一种实现方式

类的内置方法（魔法方法） 凡是在类内部定义，以——开头——结尾的方法，都是类的内置方法，也称之为魔法方法 类的内置方法, 会在某种条件下自动触发 内置方法如下： __ new __ : 在__ init __ 触发前触发，调用该类时会通过 __ new __ 产生一个新的对象 __ init __ : 在调用类时，自动触发。通过产生的对象自动调用 __ init __ ''' 类的内置方法(魔法方法): 凡是在类内部定义，以__开头__结尾的方法，都是类的内置方法，也称之为魔法方法。 类的内置方法，会在某种条件满足下自动触发。 内置方法如下: new : 在__init__触发前，自动触发。 调用该类时，内部会通过__new__产生一个新的对象。 init : 在调用类时自动触发。 通过产生的对象自动调用__init__() ''' class Demo(object): 条件: __new__: 在__init__触发前，自动触发。 def __new__(cls, *args, **kwargs): print('此处是__new__方法的执行') python内部通过object调用内部的__new__实现产生一个空的对象 ---> 内存地址 return object.__new__(cls, *args, **kwargs) 条件: __init__: 在调用类时自动触发

前言 单例模式是老生常谈的一种设计模式，同时它是最简单也是最容易被忽视的一种设计模式。 下面是一些个人看法： (1) 单例类需要保证自己的唯一性，同时也需要避免被继承，即需要使用sealed修饰； (2) 饿汉式单例先创建好实例，懒汉式单例在需要的时候再创建实例，个人倾向于后者，因为单例模式一般管理着特定资源，懒汉式单例可以避免在不需要资源的时候也会创建实例； (3) 懒汉式单例需要在多线程环境下保持唯一性，因此需要在创建实例时加锁，对私有实例做双重判空(加锁前、加锁后)，避免创建多个实例； (4) 对于资源依赖强的单例，需要使用Dispose模式(实现IDisposable接口)。 1、单例模式UML图 2、传统单例C#实现 public class Singleton { private static Singleton _instance; private Singleton() { } public static Singleton Instance { get { if (_instance == null) { _instance = new Singleton(); } return _instance; } } } 3、演进单例C#实现 public sealed class Singleton { private static Singleton

一、单例模式的应用场景 　　单例模式（singleton Pattern）是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。J2EE中的ServletContext,ServletContextConfig等；Spring中的ApplicationContext、数据库连接池等。 二、饿汉式单例模式 　　饿汉式单例模式在类加载的时候就立即初始化，并且创建单例对象。它是绝对的线程安全、在线程还没出现以前就实现了，不可能存在访问安全问题。 　　优点：没有增加任何锁，执行效率高，用户体验比懒汉式好。 　　缺点：类加载的时候就初始化了，用不用都进行，浪费内存。 　　Spring 中IoC容器ApplocationContext本身就是典型的饿汉式单例模式： public class HungrySingleton { private static final HungrySingleton h = new HungrySingleton(); private HungrySingleton() { } public static HungrySingleton getInstance() { return h; } } 　　饿汉式单例模式适用于单例对象较少的情况。 三、懒汉式单例模式 　　被外部调用才会加载： public class

定义 单例模式属于创建型模式，是设计模式中最简单的设计模式之一，其最大的特点是只有一个实例。当某一个类频繁被其他对象进行调用，为减少该类被频繁的创建和销毁，单例模式则派上用场。 单例模式主要处理多个线程的统一操作，比如计数器的实现、多线程对于统一文件的操作等等。但是单例模式的实现与Java设计原则中的单一职责原则相冲突。 实现 单例模式的实现有很多种，比如饿汉模式、懒汉模式、静态内部类，甚至枚举值实现等。每种实现方式各有特点，对于线程安全和是否延迟加载也各有不同。下面分别对于其多种实现方式进行简单介绍和实现。 　　饿汉模式 /** * 单例模式--饿汉模式: 线程安全的 */ public class SingletonDemoHungry { private static SingletonDemoHungry instance = new SingletonDemoHungry(); private SingletonDemoHungry() { } public static SingletonDemoHungry getInstance(){ return instance; } } 　　懒汉模式 /** * 单例模式--懒汉模式: 线程安全的 * * 双重校验锁的方法: 在多线程的情况下, 保证代码块只能被一个线程锁定 * volatile: 可以防止指令重排, 即保证在