什么是单例设计模式

单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。

拓展：

1、单例模式的要点：一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行 向整个系统提供这个实例。

2、单例模式优缺点：

优点：一、实例控二、灵活性

缺点：一、开销 二、可能的开发混淆三、对象生存期

3、单例模式是设计模式中最简单的形式之一。这一模式的目的是使得类的一个对象成为系统中的唯 一实例。要实现这一点，可以从客户端对其进行实例化开始。因此需要用一种只允许生成对象类 的唯一实例的机制，“阻止”所有想要生成对象的访问。使用工厂方法来限制实例化过程。这个 方法应该是静态方法（类方法），因为让类的实例去生成另一个唯一实例毫无意义。

单例模式是指一个类仅允许创建其自身的一个实例，并提供对该实例的访问权限。它包含静态变量，可以容纳其自身的唯一和私有实例。它被应用于这种场景——用户希望类的实例被约束为一个对象。在需要单个对象来协调整个系统时，它会很有帮助。

1、单例类只能有一个实例

2、单例类必须自己创建自己的唯一实例

3、单例类必须给其他所有对象提供这一实例

1.尽量使用懒加载

2.双重检索实现线程安全

3.构造方法为private

4.定义静态的Singleton instance对象和getInstance()方法

单例模式至少有六种写法。

作为一种重要的设计模式，单例模式的好处有：

1、控制资源的使用，通过线程同步来控制资源的并发访问

2、控制实例的产生，以达到节约资源的目的

3、控制数据的共享，在不建立直接关联的条件下，让多个不相关的进程或线程之间实现通信

Singleton通过将构造方法限定为private避免了类在外部被实例化，在同一个虚拟机范围内，Singleton的唯一实例只能通过getInstance()方法访问。但其实通过Java反射机制是能够实例化构造方法为private的类的，那基本上会使所有的Java单例实现失效。

虽然也是只有一个线程能够执行，假如线程B先执行，线程B获得锁，线程B执行完之后，线程 A获得锁，但是此时没有检查singleton是否为空就直接执行了，所以还会出现两个singleton实例的情况。

既然懒汉式是非线程安全的，那就要改进它。最直接的想法是，给getInstance方法加锁不就好了，但是我们不需要给方法全部加锁啊，只需要给方法的一部分加锁就好了。基于这个考虑，引入了双检锁（Double Check Lock，简称DCL）的写法：

使用volatile 的原因：

对于JVM而言，它执行的是一个个Java指令。在Java指令中创建对象和赋值操作是分开进行的，也就是说instance = new Singleton()语句是分两步执行的。但是JVM并不保证这两个操作的先后顺序，也就是说有可能JVM会为新的Singleton实例分配空间， 然后直接赋值给instance成员，然后再去初始化这个Singleton实例。这样就使出错成为了可能，我们仍然以A、B两个线程为例：

加载一个类时，其内部类不会同时被加载。一个类被加载，当且仅当其某个静态成员（静态域、构造器、静态方法等）被调用时发生。

枚举类实现单例模式是 effective java 作者极力推荐的单例实现模式，因为枚举类型是线程安全的，并且只会装载一次，设计者充分的利用了枚举的这个特性来实现单例模式，枚举的写法非常简单，而且枚举类型是所用单例实现中唯一一种不会被破坏的单例实现模式。因为枚举类没有构造方法，可以防止反序列化操作。

1、除枚举方式外, 其他方法都会通过反射的方式破坏单例,反射是通过调用构造方法生成新的对象，所以如果我们想要阻止单例破坏，可以在构造方法中进行判断，若已有实例, 则阻止生成新的实例，解决办法如下:

2、如果单例类实现了序列化接口Serializable, 就可以通过反序列化破坏单例，所以我们可以不实现序列化接口,如果非得实现序列化接口，可以重写反序列化方法readResolve(), 反序列化时直接返回相关单例对象。

Runtime是一个典型的例子，看下JDK API对于这个类的解释"每个Java应用程序都有一个Runtime类实例，使应用程序能够与其运行的环境相连接，可以通过getRuntime方法获取当前运行时。应用程序不能创建自己的Runtime类实例。"，这段话，有两点很重要：

1、每个应用程序都有一个Runtime类实例

2、应用程序不能创建自己的Runtime类实例

只有一个、不能自己创建，是不是典型的单例模式？看一下，Runtime类的写法：

为了节约系统资源，有时需要确保系统中某个类只有唯一一个实例，当这个唯一实例创建成功之后，我们无法再创建一个同类型的其他对象，所有的操作都只能基于这个唯一实例。为了确保对象的唯一性，我们可以通过单例模式来实现。

单例模式应用的场景一般发现在以下条件下：

（1）资源共享的情况下，避免由于资源操作时导致的性能或损耗等。如上述中的日志文件，应用配置。

（2）控制资源的情况下，方便资源之间的互相通信。如线程池等。

关于单例模式的漫画分析： https://mp.weixin.qq.com/s/f-sJIZHr7JUa31gKTllSFQ

单例模式的优缺点、注意事项、使用场景

1. 定义

单例模式指的是一个类，在全局范围内（整个系统中）有且只能有一个实例存在。即该类本身负责提供一种访问其唯一对象的方式，不对外提供公共的构造函数（禁用默认公共构造函数），对于该类的实例化由它自己在类的内部进行维护！

2. 优缺点

- 优点

1. 最大程度的减少了对象的创建和销毁的次数，从而降低的垃圾回收的次数

2. 节约了系统资源，尤其是内存资源

- 缺点

1. 不能继承，不能被外部实例化

2. 类干预了外部类的使用（外部实用类不能随意实例化），而不再仅仅专注于内部的逻辑（与单一职责模式有矛盾）

3. 使用场景

- 有频繁的实例化后又销毁的情况，适合考虑使用单例模式，如记录日志的log对象

- 创建对象需要消耗过多的系统资源，但又经常用到的资源，如数据库连接

4. 框架中的应用

5. 实现方式

单例模式有多种实现方式，要考虑到多线程下的安全性，其每种实现方式如下所示：

以上方式，如果存在多个线程同时访问getInstance()时，由于没有锁机制，会导致实例化出现两个实例的情况，因此，在多线程环境下时不安全的。

如上代码所示，在getInstance()方法上添加了同步锁。但是该方法虽然解决了线程安全的问题，但却也带来了另外的一个问题，就是每次获取对象时，都要先获取锁，并发性能很差，还需要继续优化！

该方法将方法上的锁去掉了，避免了每次调用该方法都要获取锁的操作，从而提升了并发性能，同时在方法内部使用锁，进而解决了并发的问题，从而解决了上面**并发安全+性能低效**的问题，是个不错的实现单例的方式。

该方式虽然简单也安全，但是会造成再不需要实例时，产生垃圾对象，造成资源狼粪，因此，一般不使用。

这种方式可以达到跟** 双重校验锁 **一样的效果，但只适用于静态域的情况，双重校验锁可在实例域需要延迟初始化时使用

这是实现单例模式的最佳方法，更加简洁，自动支持序列化，防止多次实例化，非常高效！ （强烈推荐使用）

6.引用

单例模式：保证一个类在使用过程中，只有一个实例。

优势就是单例模式的作用，这个类永远只有一个实例。

还在于可以节省内存，因为它限制了实例的个数，有利于Java垃圾回收。

java的学习建议:

首先要看书读理论，不一定都懂，因为有一个懂的过程；

然后就是分析代码，看看书上的代码的意思，逐行逐行地看，去体会；

最重要的一点就是敲写代码，刚开始不会没关系，照着书一行一行的敲，然后运行，观察结果，把程序运行结果联系程序代码，学得多一点了就尝试修改代码，改一点点看运行结果有什么变化，便于理解程序内部执行的机制。

设计模式 解决某一类问题最行之有效的方法 （java中有 种通用设计模式）单例设计模式 解决一个类在内存中只存在一个对象 单例设计模式有两种方式 ）饿汉式先初始化对象 当类一进内存就创建好对象 ）懒汉式对象是方法被调用时才初始化 也叫延时加载 类进内存时 对象还没有存在 只有通过方法调用时 才建立对象 单例设计模式 是想要保证对象的唯一 ）为了避免其他程序过多建立该类对象 先禁止其他程序建立该类对象 ）还为了让其他程序可以访问到该类对象 只好在本类中自定义一个对象 ）为了方便其他程序对自定义对象的访问 可以对外其他一些访问方式 利用这三步进行代码实现 ）将构造函数私有化 ）在类中创建一个本类对象 ）提供一个方法可以获取到该对象提示 在单例设计模式中 事物该怎么描述还怎么描述 当需要将该事物的对象保证在内存中唯一时 加上以上三步即可 代码说明 // ）饿汉式[java]class Single{private int numpublic void setNum（int num）{this num = num}public int getNum（）{return num}//将构造函数私有化private Single（）{}//在类中创建一个本类对象 因为构造函数被私有化 该类不能创建对象 想在外部访问 所以将其静态private static Single s = new Single（） //提供一个方法可以获取到该对象 不能创建对象 所以将方法静态 可以通过 （类名 方法名）的形式进行访问public static Single getInstance（）{return s}}class SingleDemo{public static void main（String[] args）{//单例的构造函数被静态后不能创建对象 保证对象的唯一 所以通过 （类名 方法名）的形式进行访问Single s = Single getInstance（） Single s = Single getInstance（） s setNum（ ） System out println（s getNum（）） //结果 因为Single单例里面对对象和方法进行了静态 数据共享 所以s 的值}}

public class LazySingle {

private LazySingle() {}

private static LazySinglesingle =null

    public static synchronized  LazySinglegetInstance() {

if (single ==null) {

single =new LazySingle()

        }

return single

    }

}

饿汉式

public class ESingle {

private ESingle(){}

private static final ESingleeSingle =new ESingle()

    public static ESinglegetInstance(){

return eSingle

    }

}

懒汉式和饿汉式区别：

实例化方面：懒汉式默认不会实例化，外部什么时候调用什么时候new。饿汉式在类加载的时候就实例化，并且创建单例对象。

线程安全方面：饿汉式线程安全 (在线程还没出现之前就已经实例化了，因此饿汉式线程一定是安全的)。懒汉式线程不安全( 因为懒汉式加载是在使用时才会去new 实例的，那么你去new的时候是一个动态的过程，是放到方法中实现的，比如：public static synchronized Lazy getInstance(){   if(lazy==null){  lazy=new Lazy()} 如果这个时候有多个线程访问这个实例，这个时候实例还不存在，还在new，就会进入到方法中，有多少线程就会new出多少个实例。一个方法只能return一个实例，那最终return出哪个呢？是不是会覆盖很多new的实例？这种情况当然也可以解决，那就是加同步锁，避免这种情况发生) 。

执行效率上：饿汉式没有加任何的锁，因此执行效率比较高。懒汉式一般使用都会加同步锁，效率比饿汉式差。

性能上：饿汉式在类加载的时候就初始化，不管你是否使用，它都实例化了，所以会占据空间，浪费内存。懒汉式什么时候需要什么时候实例化，相对来说不浪费内存。

定义：

确保某一个类只有一个实例，而且自动实例化并向整个系统提供这个实例。

通用类图：

通用代码：

Singleton类称为单例类，通过使用private的构造函数确保了在一个应用中只产生一个实例，并且是自行实例化的。

public class Singleton {

private static final Singleton singleton = new Singleton()

// 限制产生多个对象

private Singleton() {

}

// 通过该方法获得实例对象

public static Singleton getSingleton() {

return singleton

}

// 类中其他方法尽量是static

public static void doSomething() {

}

}

单例模式的优点：

由于单例模式在内存中只有一个实例，减少了内存开支，特别是一个对象需要频繁地创建、销毁时，而且创建或销毁时性能又无法优化，单例模式的优势就非常明显了。

由于单例模式只生成一个实例，所以减少了系统的性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后用永久驻留内存的方式来解决。

单例模式可以避免对资源的多重占用，例如一个写文件动作，由于只有一个实例存在内存中，避免对同一个资源文件的同时写操作。

单例模式可以在系统设置全局的访问点，优化和共享资源访问，例如可以设计一个单例类，负责所有数据表的映射处理。

单例模式的缺点：

单例模式一般没有接口，扩展很困难，若要扩展，除了修改代码基本上没有第二种途径可以实现。

单例模式对测试是不利的。在并行开发环境中，如果单例模式没有完成，是不能进行测试的，没有接口也不能用mock的方式虚拟一个对象。

单例模式与单一职责原则有冲突。一个类应该只实现一个逻辑，而不关心它是否是单例的，是不是要单例取决于环境，单例模式把“要单例”和业务逻辑融合在一个类中。

单例模式的使用场景：

要求生成唯一序列号的环境；

在整个项目中需要一个共享访问点或共享数据，例如一个Web页面上的计数器，可以不用把每次刷新都记录到数据库中，使用单例模式保持计数器的值，并确保是线程安全的；

创建一个对象需要消耗的资源过多，如要访问IO和数据库等资源；

需要定义大量的静态常量和静态方法（如工具类）的环境，可以采用单例模式（当然，也可以直接声明为static的方式）。

单例模式的注意事项：

1. 在高并发情况下，请注意单例模式的线程同步问题。

public class Singleton2 {

private static Singleton2 singleton = null

// 限制产生多个对象

private Singleton2() {

}

// 通过该方法获得实例对象

public static Singleton2 getSingleton() {

synchronized (singleton) {

if (singleton == null) {

singleton = new Singleton2()

}

}

return singleton

}

}

如果不加synchronized进行控制，如果第一个线程A执行到singleton = new Singleton2()，但还没有获得对象，第二个线程B也在执行，执行到if (singleton == null)判断，那么线程B获得判断条件为真，于是继续运行下去，线程A和B都获得了对象，内存中就出现了两个对象。

建议使用饿汉式单例，那是线程安全的单例模式。

2. 需要考虑对象的复制情况。在Java中，若实现Cloneable接口，并实现了clone方法，则可以直接通过对象复制方式创建一个新对象，对象复制是不用调用类的构造函数的。

3. 注意JVM的垃圾回收机制，如果我们的一个单例对象在内存中长久不使用，JVM就认为这是一个垃圾对象，在CPU资源空闲的情况下该对象会被清理掉，下次再调用时就需要产生一个新对象。如果该对象作为有状态值的管理，则会出现状态恢复原状的情况，就会出现故障。

有两种方法可以解决该问题

1、由容器管理单例的生命周期

Java EE容器或者框架级容器（如Spring）可以让对象长久驻留内存。

2、状态随时记录

可以使用异步记录的方式，或者使用观察者模式，记录状态的变化，写入文件或写入数据库中，确保即使单例对象重新初始化也可以从资源环境获得销毁前的数据，避免应用数据丢失。

单例模式的扩展：

能产生固定数量实例的单例模式

public class Singleton3 {

// 最多能产生的实例数

private static int maxNumOfSingleton = 2

// 定义一个列表，容纳所有实例

private static ArrayList<Singleton3>singletonList = new ArrayList<Singleton3>()

// 产生所有对象

static {

for (int i = 0i <maxNumOfSingletoni++) {

singletonList.add(new Singleton3())

}

}

// 限制其他类生成对象

private Singleton3() {

}

// 随机获得一个实例

public static Singleton3 getInstance() {

Random random = new Random()

return singletonList.get(random.nextInt(maxNumOfSingleton))

}

}

一、基本的实现思路:

单例的实现主要是通过以下两个步骤：

1、将该类的构造方法定义为私有方法，这样其他处的代码就无法通过调用该类的构造方法来实例化该类的对象，只有通过该类提供的静态方法来得到该类的唯一实例；

2、在该类内提供一个静态方法，当我们调用这个方法时，如果类持有的引用不为空就返回这个引用，如果类保持的引用为空就创建该类的实例并将实例的引用赋予该类保持的引用。

二、示范如下：

1、枚举实现单例：

2、懒汉式线程不安全：

3、懒汉式线程安全：

4、饿汉式：

5、双重校验锁：

6、静态内部类：

扩展资料:

一、单列模式简介：

单例模式是设计模式中最简单的形式之一。这一模式的目的是使得类的一个对象成为系统中的唯一实例。要实现这一点，可以从客户端对其进行实例化开始。因此需要用一种只允许生成对象类的唯一实例的机制，“阻止”所有想要生成对象的访问。使用工厂方法来限制实例化过程。这个方法应该是静态方法（类方法），因为让类的实例去生成另一个唯一实例毫无意义。

二、懒汉与饿汉：

1、懒汉方式：指全局的单例实例在第一次被使用时构建。

2、饿汉方式：指全局的单例实例在类装载时构建。

三、单例模式的三要点：

1、某个类只能有一个实例。

2、它必须自行创建这个实例。

3、它必须自行向整个系统提供这个实例。

四、优缺点：

1、优点：

①实例控制：单例模式会阻止其他对象实例化其自己的单例对象的副本，从而确保所有对象都访问唯一实例。

②灵活性：因为类控制了实例化过程，所以类可以灵活更改实例化过程。

2、缺点：

①开销：虽然数量很少，但如果每次对象请求引用时都要检查是否存在类的实例，将仍然需要一些开销。可以通过使用静态初始化解决此问题。

②可能的开发混淆：使用单例对象（尤其在类库中定义的对象）时，开发人员必须记住自己不能使用new关键字实例化对象。因为可能无法访问库源代码，因此应用程序开发人员可能会意外发现自己无法直接实例化此类。

③对象生存期：不能解决删除单个对象的问题。在提供内存管理的语言中（例如基于.NET Framework的语言），只有单例类能够导致实例被取消分配，因为它包含对该实例的私有引用。在某些语言中（如 C++），其他类可以删除对象实例，但这样会导致单例类中出现悬浮引用。

参考资料：百度百科单列模式

模式本身很简单，除了牵涉多线程安全问题引起的一点罗唆外。所以，我不太想讨论GOF提供的关于该模式的参考实现。我所关注的是它背后带来的对问题的看法和思考方式。

我们先看看单例模式出现的背景很存在的意义。单例模式通俗来讲就是确保类只有一个实例。那么好，我们问一下，为什么要确保类只有一个实例呢？其实无非是两个方面的作用：一、想控制资源的使用，它又体现在两个方面，其中之一是控制实例数目的产生来节约资源，其二通过线程同步控制资源的并发访问；二、想作为一种通信媒介，在不建立直接关联的条件下让不相关的两个程序进行通信，尤其是多线程。第二点，我说的有些抽象，简单讲吧，就类似于大家基于一个黑板讨论东西，而不关心参与讨论的对象。单例就取了黑板的作用。