设计模式-单例模式

定义

单例模式 ： 确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。

应用场景

J2EE标准中，ServletContext\ServletContextConfig等。

spring中的AppliationContext

数据库的连接池

。。。。

实现方式

（1）饿汉式

特点：在类加载的时候就立即创建单例对象。绝对线程安全，因为在线程还未出现前就实例化了，不可能出现访问安全问题。

优点：没有加任何的锁，执行效率高，用户体验好

缺点：类加载的时候就初始化，不管是否使用到都占着空间，可能会造成内存浪费

例子：spring IOC容器ApplicationContext就是典型的饿汉式单例。

方式一：

public class HungrySingleton {
//先静态、后动态
//先属性、后方法
//先上后下
private static final HungrySingleton hungrySingleton = new HungrySingleton();
private HungrySingleton(){}
public static HungrySingleton getInstance(){
return hungrySingleton;
}
}

方式二：

//饿汉式静态块单例
public class HungryStaticSingleton {
private static final HungryStaticSingleton hungrySingleton;
static {
hungrySingleton = new HungryStaticSingleton();
}
private HungryStaticSingleton(){}
public static HungryStaticSingleton getInstance(){
return hungrySingleton;
}
}

（2）懒汉式

特点：被外部调用的时候才会实例化

 

//懒汉式单例
//在外部需要使用的时候才进行实例化
public class LazySimpleSingleton {
private LazySimpleSingleton(){}
//静态块，公共内存区域
private static LazySimpleSingleton lazy = null;
public static LazySimpleSingleton getInstance(){
if(lazy == null){
lazy = new LazySimpleSingleton();
}
return lazy;
}
}

public class ExectorThread implements Runnable{
@Override
public void run() {
LazySimpleSingleton singleton = LazySimpleSingleton.getInstance();
System.out.println(Thread.currentThread().getName() + ":" + singleton);
}
}

public class LazySimpleSingletonTest {
public static void main(String[] args) {
Thread t1 = new Thread(new ExectorThread());
Thread t2 = new Thread(new ExectorThread());
t1.start();
t2.start();
System.out.println("End");
}
}

运行结果：

通过不断切换线程，并观测其内存状态，我们发现在线程环境下LazySimpleSingleton

被实例化了两次。有时，我们得到的运行结果可能是相同的两个对象，实际上是被后面

执行的线程覆盖了，我们看到了一个假象，线程安全隐患依旧存在。那么，我们如何来

优化代码，使得懒汉式单例在线程环境下安全呢？来看下面的代码，给getInstance()加

上synchronized 关键字，是这个方法变成线程同步方法：

public class LazySimpleSingleton {
private LazySimpleSingleton(){}
//静态块，公共内存区域
private static LazySimpleSingleton lazy = null;
public synchronized static LazySimpleSingleton getInstance(){
if(lazy == null){
lazy = new LazySimpleSingleton();
}
return lazy;
}
}

这时候，我们再来调试。当我们将其中一个线程执行并调用getInstance()方法时，另一

个线程在调用getInstance()方法，线程的状态由RUNNING 变成了MONITOR,出现阻

塞。直到第一个线程执行完，第二个线程才恢复RUNNING 状态继续调用getInstance()

方法。

线程安全的问题便解决了。但是，用synchronized 加锁，在线程数量比较多情况下，如果CPU 分配压力上升，会导致大批

量线程出现阻塞，从而导致程序运行性能大幅下降。那么，有没有一种更好的方式，既兼顾线程安全又提升程序性能呢？答案是肯定的。我们来看双重检查锁的单例模式：

public class LazyDoubleCheckSingleton {
private volatile static LazyDoubleCheckSingleton lazy = null;
private LazyDoubleCheckSingleton(){}
public static LazyDoubleCheckSingleton getInstance(){
if(lazy == null){
synchronized (LazyDoubleCheckSingleton.class){
if(lazy == null){
lazy = new LazyDoubleCheckSingleton();
//1.分配内存给这个对象
//2.初始化对象
//3.设置lazy 指向刚分配的内存地址
}
}
}
return lazy;
}
}

但是，用到synchronized 关键字，总归是要上锁，对程序性能还是存在一定影响的。难

道就真的没有更好的方案吗？当然是有的。我们可以从类初始化角度来考虑，看下面的

代码，采用静态内部类的方式：

//这种形式兼顾饿汉式的内存浪费，也兼顾synchronized 性能问题
//完美地屏蔽了这两个缺点
public class LazyInnerClassSingleton {
//默认使用LazyInnerClassGeneral 的时候，会先初始化内部类
//如果没使用的话，内部类是不加载的
private LazyInnerClassSingleton(){}
//每一个关键字都不是多余的
//static 是为了使单例的空间共享
//保证这个方法不会被重写
public static final LazyInnerClassSingleton getInstance(){
//在返回结果以前，一定会先加载内部类
return LazyHolder.LAZY;
}
//默认不加载
private static class LazyHolder{
private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();
}
}

反射破坏单例

大家有没有发现，上面介绍的单例模式的构造方法除了加上private 以外，没有做任何处

理。如果我们使用反射来调用其构造方法，然后，再调用getInstance()方法，应该就会

两个不同的
实例。现在来看一段测试代码，以LazyInnerClassSingleton 为例：

public class LazyInnerClassSingletonTest {
public static void main(String[] args) {
try{
//很无聊的情况下，进行破坏
Class<?> clazz = LazyInnerClassSingleton.class;
//通过反射拿到私有的构造方法
Constructor c = clazz.getDeclaredConstructor(null);
//强制访问，强吻，不愿意也要吻
c.setAccessible(true);
//暴力初始化
Object o1 = c.newInstance();
//调用了两次构造方法，相当于new 了两次

//犯了原则性问题，

Object o2 = c.newInstance();

System.out.println(o1 == o2);

// Object o2 = c.newInstance();

}catch (Exception e){

e.printStackTrace();

}

}

}

显然，是创建了两个不同的实例。现在，我们在其构造方法中做一些限制，一旦出现多

次重复创建，则直接抛出异常。来看优化后的代码：

//史上最牛B 的单例模式的实现方式
public class LazyInnerClassSingleton {
//默认使用LazyInnerClassGeneral 的时候，会先初始化内部类
//如果没使用的话，内部类是不加载的
private LazyInnerClassSingleton(){
if(LazyHolder.LAZY != null){
throw new RuntimeException("不允许创建多个实例");
}
}
//每一个关键字都不是多余的
//static 是为了使单例的空间共享
//保证这个方法不会被重写，重载
public static final LazyInnerClassSingleton getInstance(){
//在返回结果以前，一定会先加载内部类
return LazyHolder.LAZY;
}
//默认不加载
private static class LazyHolder{
private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();
}

序列化破坏单例

当我们将一个单例对象创建好，有时候需要将对象序列化然后写入到磁盘，下次使用时

再从磁盘中读取到对象，反序列化转化为内存对象。反序列化后的对象会重新分配内存，

即重新创建。那如果序列化的目标的对象为单例对象，就违背了单例模式的初衷，相当

于破坏了单例，来看一段代码：

//反序列化时导致单例破坏
public class SeriableSingleton implements Serializable {
//序列化就是说把内存中的状态通过转换成字节码的形式
//从而转换一个IO 流，写入到其他地方(可以是磁盘、网络IO)
//内存中状态给永久保存下来了
//反序列化
//讲已经持久化的字节码内容，转换为IO 流
//通过IO 流的读取，进而将读取的内容转换为Java 对象
//在转换过程中会重新创建对象new
public final static SeriableSingleton INSTANCE = new SeriableSingleton();
private SeriableSingleton(){}
public static SeriableSingleton getInstance(){
return INSTANCE;
}
}

public class SeriableSingletonTest {
public static void main(String[] args) {
SeriableSingleton s1 = null;
SeriableSingleton s2 = SeriableSingleton.getInstance();
FileOutputStream fos = null;
try {
fos = new FileOutputStream("SeriableSingleton.obj");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(s2);
oos.flush();
oos.close();
FileInputStream fis = new FileInputStream("SeriableSingleton.obj");
ObjectInputStream ois = new ObjectInputStream(fis);
s1 = (SeriableSingleton)ois.readObject();
ois.close();
System.out.println(s1);
System.out.println(s2);
System.out.println(s1 == s2); //false
} catch (Exception e) {
e.printStackTrace();
}
}
}

运行结果中，可以看出，反序列化后的对象和手动创建的对象是不一致的，实例化了两

次，违背了单例的设计初衷。那么，我们如何保证序列化的情况下也能够实现单例？其

实很简单，只需要增加readResolve()方法即可。来看优化代码：

package com.gupaoedu.vip.pattern.singleton.seriable;
import java.io.Serializable;
public class SeriableSingleton implements Serializable {
public final static SeriableSingleton INSTANCE = new SeriableSingleton();
private SeriableSingleton(){}
public static SeriableSingleton getInstance(){
return INSTANCE;
}
private Object readResolve(){
return INSTANCE;
}
}

虽然，增加readResolve()方法返回实例，解决了单

例被破坏的问题。但是，我们通过分析源码以及调试，我们可以看到实际上实例化了两

次，只不过新创建的对象没有被返回而已。那如果，创建对象的动作发生频率增大，就

意味着内存分配开销也就随之增大，难道真的就没办法从根本上解决问题吗？下面我们

来注册式单例也许能帮助到你。

注册式单例

注册式单例又称为登记式单例，就是将每一个实例都登记到某一个地方，使用唯一的标

识获取实例。注册式单例有两种写法：一种为容器缓存，一种为枚举登记。先来看枚举

式单例的写法，来看代码，创建EnumSingleton 类：

public enum EnumSingleton {
INSTANCE;
private Object data;
public Object getData() {
return data;
}
public void setData(Object data) {
this.data = data;
}
public static EnumSingleton getInstance(){
return INSTANCE;
}
}

public class EnumSingletonTest {
public static void main(String[] args) {
try {
EnumSingleton instance1 = null;
EnumSingleton instance2 = EnumSingleton.getInstance();
instance2.setData(new Object());
FileOutputStream fos = new FileOutputStream("EnumSingleton.obj");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(instance2);
oos.flush();
oos.close();
FileInputStream fis = new FileInputStream("EnumSingleton.obj");
ObjectInputStream ois = new ObjectInputStream(fis);
instance1 = (EnumSingleton) ois.readObject();
ois.close();
System.out.println(instance1.getData());
System.out.println(instance2.getData());
System.out.println(instance1.getData() == instance2.getData()); //true
}catch (Exception e){
e.printStackTrace();
}
}
}

那么反射是否能破坏枚举式单例呢？来看一段测试代码：

public static void main(String[] args) {
try {
Class clazz = EnumSingleton.class;
Constructor c = clazz.getDeclaredConstructor();
c.newInstance();
}catch (Exception e){
e.printStackTrace();
}
}

报的是java.lang.NoSuchMethodException 异常，意思是没找到无参的构造方法。这
时候，我们打开java.lang.Enum 的源码代码，查看它的构造方法，只有一个protected
的构造方法，代码如下：

protected Enum(String name, int ordinal) {
this.name = name;
this.ordinal = ordinal;
}

那我们再来做一个这样的测试：

public static void main(String[] args) {
try {
Class clazz = EnumSingleton.class;
Constructor c = clazz.getDeclaredConstructor(String.class,int.class);
c.setAccessible(true);
EnumSingleton enumSingleton = (EnumSingleton)c.newInstance("Tom",666);
}catch (Exception e){
e.printStackTrace();
}
}

这时错误已经非常明显了，告诉我们Cannot reflectively create enum objects，不能

用反射来创建枚举类型。

接下来看注册式单例还有另一种写法，容器缓存的写法，创建ContainerSingleton 类：

public class ContainerSingleton {
private ContainerSingleton(){}
private static Map<String,Object> ioc = new ConcurrentHashMap<String,Object>();
public static Object getBean(String className){
synchronized (ioc) {
if (!ioc.containsKey(className)) {
Object obj = null;
try {
obj = Class.forName(className).newInstance();
ioc.put(className, obj);
} catch (Exception e) {
e.printStackTrace();
}
return obj;
} else {
return ioc.get(className);
}
}
}
}

 

转载于:https://www.cnblogs.com/yintingting/p/11614575.html