单例模式中的饿汉和懒汉模式
Posted 筑梦小子
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了单例模式中的饿汉和懒汉模式相关的知识，希望对你有一定的参考价值。
目录
一.什么是单例模式
保证某个类在程序中只存在一份实例，而不会创建多个实例，这样就会提高效率。
在单利模式中一般只提供一个getInstance()方法来获取实例对象，不提供setInstance()方法,目的是为了避免再实例化出其他实例对象。
其中单例模式中有两种模式一种是饿汉模式，一种是懒汉模式。
一.饿汉模式
1.饿汉模式的概念
饿汉模式就是在类加载的时候立刻会实例化，后续使用就只会出现一份实例。
2.饿汉模式代码
package thread.example;
//饿汉模式
public class HungrySingle
//在类加载的时候就实例化了，类加载只有一次，所以值实例化出了一份该实例对象
private static HungrySingle instance = new HungrySingle();
public static HungrySingle getInstance()
return instance;
2.多线程是否线程安全
在类加载的时候就已经实例化了，所以该实例化没有涉及到实例化的修改操作，只是进行读取操作。在多线程情况下是线程安全的。
二.懒汉模式
1.懒汉模式的概念
在类加载的时候没有直接实例化，而是调用指定实例方法的时候再进行实例化，这样就能保证不想使用的时候也不会实例化。一般来说比饿汉模式的效率高。
2.单线程情况下的懒汉模式
package thread.example;
//单线程的懒汉模式
public class LazySingle
private static LazySingle instance = null;
//只有在调用该方法的时候才实例化
public static LazySingle getInstance()
if(instance == null)
instance = new LazySingle();
return instance;
2.多线程情况下的懒汉模式
（1）导致懒汉模式在多线程情况下的不安全原因
在多线程的情况下，由于可能两个线程都会得到一份instance=null，这是因为如果线程1修改了自己县城中的instance后还没来得及修改主内存中的instance，所导致线程2也实例化出了一份instance对象，这时候也就不再是单例模式了。主要导致该问题的是由于这里面涉及到了对instance的修改操作，失去了原子性，为了保证原子性，我们想到了加锁，从而实现线程安全问题。
（2）解决方法代码示例
版本1
package thread.example;
//多线程安全下的懒汉模式
public class LazySingle
private LazySingle()
private static LazySingle instance = null;
//只有在调用该方法的时候才实例化
public static synchronized LazySingle getInstance()
if (instance == null)
instance = new LazySingle();
return instance;
版本1的代码虽然保证了线程安全，但是每次调用该方法时还是会出现加锁解锁问题，为了进一步优化，我们可以减小锁的粒度来提高效率，因为加了锁之后也就和高并发无缘了，但我们还是想提高效率，所以才会进行优化。
版本2
双重if判断加锁提高效率
package thread.example;
public class SecurityLazyModle
private LazySingle()
private static volatile SecurityLazyModle instance = null;//保证内存可见性，防止编译器过度优化(指令重排序)
public static SecurityLazyModle getInstance()
if(instance == null)
synchronized (SecurityLazyModle.class)
if(instance == null)
instance = new SecurityLazyModle();
return instance;
版本2的解释说明
第一层if是为了判断当前是否已经把实例创建出来，第二层synchronized是为了使进入当前if中的线程来竞争锁，当拿到锁的线程进入到第三层if之后判断是否为空，不为空就是实例化对象，然后再释放锁，释放锁之后，instance已经不为空了，后面的线程就被阻挡在了第三层if这里了，之后再来访问getInstance()方法，发现该instance已经不为空了，也就不用再抢占锁资源了，因为竞争锁也消耗大量的时间。通过这样处理，既保证了线程安全，也提高了效率。
这里使用volatile是为了防止编译器优化导致的指令重排序，在进行new一个对象不是原子性操作，可以分为三步骤：
1.分配内存空间
2.实例化对象
3.给变量赋值
对于上面的执行，如果1和3先执行了（假设2还没有完成），在第一层if外的线程这时候判断不为null,这时候就会直接返回该对象，但是这个对象只执行了一半，之后使用就会导致线程安全问题。
通过volatile就可以确保这3步骤必须执行完（无论顺序如何，最终都会执行完），外面的线程才可以执行，这时候就保证了该对象的完整性。
Java单例模式的七种写法
概念简介
单例模式是一种常用的软件设计模式，其定义是单例对象的类只能允许一个实例存在。主要分为 饿汉式 和 懒汉式 这两种实现方式
饿汉 和 懒汉主要区别在于 实例 初始化的时机不同
饿汉式 ：类加载的时候就初始化了实例，容易造成内存浪费。
懒汉式 :需要使用时初始化实例，容易造成线程不安全
实现思路简介
- 构造方法私有化，保证不可以随便就能创建一个对象。
- 静态变量存储实例。
- 公开方法暴露实例
以上总结的三步，不管是饿汉，还是懒汉，皆可以适用。他们之间的区别在于如何给这个 静态变量 赋值。
注意事项
懒汉方式中得注意线程安全。
单例模式的七种写法
1、饿汉式（静态常量）【可用】
package com.wust;
public class SingMode
private static SingMode INSTANCE = new SingMode();
private SingMode()
public static SingMode getInstance()
return INSTANCE;
2、饿汉式（静态代码块）【可用】
package com.wust;
public class SingMode
private static SingMode INSTANCE;
static
INSTANCE = new SingMode();
private SingMode()
public static SingMode getInstance()
return INSTANCE;
优点：这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题。
缺点：在类装载的时候就完成实例化，没有达到Lazy Loading的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费。
3、懒汉式（线程不安全）【不可用】
package com.wust;
public class SingMode
private static SingMode INSTANCE;
private SingMode()
public static SingMode getInstance()
if (INSTANCE == null)
INSTANCE = new SingMode();
return INSTANCE;
这种写法起到了Lazy Loading的效果，但是只能在单线程下使用。如果在多线程下，一个线程进入了if (singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式。
4、懒汉式（线程安全，效率低）【不推荐使用】
package com.wust;
public class SingMode
private static SingMode INSTANCE;
private SingMode()
public static synchronized SingMode getInstance()
if (INSTANCE == null)
INSTANCE = new SingMode();
return INSTANCE;
解决上面第三种实现方式的线程不安全问题，做个线程同步就可以了，于是就对getInstance()方法进行了线程同步。
缺点：效率太低了，每个线程在想获得类的实例时候，执行getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接return就行了。方法进行同步效率太低要改进。
5、懒汉式（线程不安全）【不可用】
package com.wust;
public class SingMode
private static SingMode INSTANCE;
private SingMode()
public static SingMode getInstance()
if (INSTANCE == null)
synchronized (SingMode.class)
INSTANCE = new SingMode();
return INSTANCE;
缺点：假如一个线程进入了if (singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。
6、双重检查[推荐用]
package com.wust;
public class SingMode
private static SingMode INSTANCE;
private SingMode()
public static SingMode getInstance()
if (INSTANCE == null)
synchronized (SingMode.class)
if (INSTANCE == null)
INSTANCE = new SingMode();
return INSTANCE;
Double-Check概念对于多线程开发者来说不会陌生，如代码中所示，我们进行了两次if (singleton == null)检查，这样就可以保证线程安全了。这样，实例化代码只用执行一次，后面再次访问时，判断if (singleton == null)，直接return实例化对象。
优点：线程安全；延迟加载；效率较高。
7、静态内部类[推荐用]
package com.wust;
public class SingMode
private SingMode()
private static class SingModeInstance
private static SingMode INSTANCE = new SingMode();
public static SingMode getInstance()
return SingModeInstance.INSTANCE;
这种方式跟饿汉式方式采用的机制类似，但又有不同。两者都是采用了类装载的机制来保证初始化实例时只有一个线程。不同的地方在饿汉式方式是只要Singleton类被装载就会实例化，没有Lazy-Loading的作用，而静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载SingletonInstance类，从而完成Singleton的实例化。
类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。
优点：避免了线程不安全，延迟加载，效率高。
以上是关于单例模式中的饿汉和懒汉模式的主要内容，如果未能解决你的问题，请参考以下文章