Java中的23个设计模式 【创造型模式】 中的 【单例模式】
文章目录
- 设计模式分类
- 单例模式
-
- 常见的五种单例模式实现方式
- 饿汉式(单例对象立即加载)
- 懒汉式(单例对象延迟加载)
- 双重检测锁模式
- 静态内部类实现方式（也是一种懒加载方式）
- 枚举实现单例模式
- 问题：
-
- 通过反射破解懒汉式单例
-
- 解决办法
- 通过反序列化破解懒汉式单例模式
-
- 解决办法
- 多线程环境下测试单例模式的效率
设计模式分类
- 创建型模式
- 单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式
- 关注对象的创建过程
- 结构型模式
- 适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式
- 关注对象和类的组织
- 行为型模式
- 模板方法模式、
命令模式、迭代器模式、观察者模式、中介模式、备忘录模式、解释器模式、状态模式、策略模式、责任链模式、访问者模式- 关注系统同对象之间的相互交互，研究系统在运行时对象之间的相互通信和协作，进一步明确对象的职责
单例模式
- 核心作用：
- 保证一个类只有一个实例，并且提供一个访问该实例的全局访问点
- 常见应用场景
- Windows的Task Manager（任务管理器）就是很典型的单例模式
- Windows的Recycle Bin（回收站）也是典型的单例应用。在整个系统运行过程中，回收站一直维护者仅有的一个实例
- 项目中，读取配置文件的类，一般也只有一个对象。没有必要每次使用配置文件数据，每次new一个对象去读取
- 网站的计数器，一般也是采用单例模式实现的，否则难以同步
- 应用程序的日志应用，一般都用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加
- 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源
- 操作系统的文件系统，也是大的单例模式实现的具体例子，一个操作系统只能有一个文件系统
- Application 也是单例的典型应用（Servlet编程中会涉及到）
- 在Spring中，每个Bean默认就是单例的，这样做的优点是Spring容器可以管理
- 在Servlet编程中，每个Servlet也是单例
- 在Spring MVC框架/struts1框架中，控制器对象也是单例
- 单例模式的优点
- 由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永远驻留内存的方式来解决
- 单例模式可以在系统设置全局的访问点，优化环共享资源访问，例如可以设计一个单例类，负责所有数据表的映射处理
常见的五种单例模式实现方式
- 主要
- 饿汉式（线程安全，调用效率高。不能延迟加载）
- 懒汉式（线程安全，调用效率不高，可以延迟加载）
- 其他
- 双重检测锁式（由于JVM底层内部模型原因，偶尔会出问题，不建议使用）
- 静态内部类式（线程安全，调用效率高可以延迟加载）
- 枚举单例（线程安全，调用效率高，不能延迟加载）
- 如何选择
- 单例对象，占用资源少，不需要延迟加载
- 枚举式 好于 饿汉式
- 单例对象，占用资源大，需要延迟加载
- 静态内部类式 好于 懒汉式
- 单例对象，占用资源少，不需要延迟加载
饿汉式(单例对象立即加载)
-
饿汉式单例模式代码中，static变量会在类装载时初始化，此时也不会涉及多个线程对象访问该对象的问题。虚拟机保证只会装载一次该类，肯定不会发生并发访问的问题。因此，可以省略
synchronized关键字 -
问题：如果只是加载本类，而不是要调用getInstance()，甚至永远没有调用，则会造成资源浪费
-
代码例子：
package testsingleton; //singleton---单例 /** * 测试饿汉式单例模式 */ public class SingletonDemo01 { //类初始化时，立即加载这个对象（没有延迟加载的优势）。加载类时，天然的是线程安全的 private static SingletonDemo01 instance = new SingletonDemo01(); private SingletonDemo01() { //私有化构造器 } //方法没有同步，调用效率高， public static SingletonDemo01 getInstance() { return instance; } }
懒汉式(单例对象延迟加载)
-
要点：
- lazy load！(延迟加载，懒加载)，真正用的时候才加载
-
问题：
- 资源利用率高了，但是，每次调用
getInstance()方法都要同步，并发效率较低
- 资源利用率高了，但是，每次调用
-
代码例子：
package testsingleton; /** * 测试懒汉式单例模式 * @author 橙汁儿Drk * */ public class SingletonDemo2 { //类初始化时，不初始化这个对象（延迟加载，真正用的时候再创建）。 private static SingletonDemo2 instance; private SingletonDemo2() { //私有化构造器 } //方法同步，调用效率低。 public static synchronized SingletonDemo2 getInstance() { if (instance null) { instance = new SingletonDemo2(); } return instance; } }
双重检测锁模式
-
这个模式将同步内容下放到if内部，提高了执行的效率，不必每次获取对象时都进行同步，只有第一次同步创建了以后就没必要了。
-
问题：
- 由于编译器优化原因和JVM底层内部模型原因，偶尔会出问题。不建议使用
public class SingletonDemo03{
private static SingletonDemo03 instance = null;
public static SingletonDemo03 getInstance(){
if(instance null){
SingletonDemo03 sc;
sychronized(SingletonDemo03.class){
sc = instance;
if(sc null){
sychronized(SingletonDemo03.class){
if(sc null){
sc = new SingletonDemo03();
}
}
instance = sc;
}
}
}
return instance;
}
private SingletonDemo03(){
}
}
静态内部类实现方式（也是一种懒加载方式）
-
要点
- 外部类没有static属性，则不会像饿汉式那样立即加载对象
- 只有真正调用getInstance(),才会加载静态内部类。加载类时是线程安全的。instance是static final类型，保证了内存中只有这样一个实例存在，而且只能被赋值一次，从而保证了线程安全性。
- 兼备了并发高效调用和延迟加载的优势
-
代码：
package testsingleton; /** * 测试静态内部类实现单例模式 * 这种方式线程安全，调用效率高，实现延迟加载 * @author 橙汁儿Drk * */ public class SingletonDemo3 { private static class SingletonClassInstance{ private static final SingletonDemo3 instance = new SingletonDemo3(); } //方法同步，调用效率低。 public static synchronized SingletonDemo3 getInstance() { return SingletonClassInstance.instance; } public SingletonDemo3() { } }
枚举实现单例模式
-
优点：
- 实现简单
- 枚举本身就是单例模式，由JVM从根本上提供保障！避免通过反射和反序列化的漏洞！
-
缺点：
- 无延迟加载
-
代码：
package testsingleton; /** * 测试枚举实现单例模式 * 没有延迟加载 * * @author 橙汁儿Drk * */ public enum SingletonDemo4 { //这个枚举元素，本身就是单例对象 INSTANCE; //添加自己需要的操作 public void singletonOperation() { } } -
System.out.println(SingletonDemo4.INSTANCESingletonDemo4.INSTANCE);的结果为true
问题：
- 反射可以破解上面几种(不包括枚举式)实现方式！（可以在构造方法中手动抛出异常控制）
- 反序列化可以破解上面几种(不包括枚举式)实现方式！
- 可以通过定义readResolve()防止获取不同的对象
- 反序列化时，如果对象所在的类定义了readresolve()，（实际是一种回调），定义返回哪个对象
- 可以通过定义readResolve()防止获取不同的对象
通过反射破解懒汉式单例
package testsingleton;
import java.lang.reflect.Constructor;
/**
* 测试反射破解单例模式
* @author 橙汁儿Drk
*
*/
public class Client2 {
public static void main(String[] args) throws Exception {
SingletonDemo5 s1 = SingletonDemo5.getInstance();
SingletonDemo5 s2 = SingletonDemo5.getInstance();
System.out.println(s1);
System.out.println(s2);
//--------------------------------------------------------------
Class<SingletonDemo5> clazz = (Class<SingletonDemo5>) Class.forName("testsingleton.SingletonDemo5");
Constructor<SingletonDemo5> c = clazz.getDeclaredConstructor(null);
c.setAccessible(true);//设置私有可访问权限
SingletonDemo5 s3 = c.newInstance();
SingletonDemo5 s4 = c.newInstance();
System.out.println(s3);
System.out.println(s4);
}
}
//---------------------------------
//结果
testsingleton.SingletonDemo5@15db9742//s1
testsingleton.SingletonDemo5@15db9742//s2
//发现通过反射破解了懒汉式单例，创建了两个不同的对象
testsingleton.SingletonDemo5@6d06d69c//s3
testsingleton.SingletonDemo5@7852e922//s4
解决办法
- 在构造器中添加if(){}语句，判断instance是否为null，不为null则抛出异常
package testsingleton;
public class SingletonDemo5 {
private static SingletonDemo5 instance;
private SingletonDemo5() {
//通过抛出异常来阻止通过反射创建新的对象
if(instance != null) {
throw new RuntimeException(); }
}
public static synchronized SingletonDemo5 getInstance() {
if (instance null) {
instance = new SingletonDemo5();
}
return instance;
}
}
//反射调用构造方法时会抛出异常
通过反序列化破解懒汉式单例模式
package testsingleton;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
/**
* 测试反射和反序列化破解单例模式
* @author 橙汁儿Drk
*
*/
public class Client2 {
public static void main(String[] args) throws Exception {
SingletonDemo5 s1 = SingletonDemo5.getInstance();
SingletonDemo5 s2 = SingletonDemo5.getInstance();
System.out.println(s1);
System.out.println(s2);
//通过反序列化的方式构造多个对象
FileOutputStream fos = new FileOutputStream("E:/MyJava/a.txt");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(s1);
oos.close();
fos.close();
//反序列化，读取对象
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("E:/MyJava/a.txt"));
SingletonDemo5 s3 = (SingletonDemo5) ois.readObject();
System.out.println(s3);
}
}
//结果----------------------------------------
testsingleton.SingletonDemo5@15db9742//s1
testsingleton.SingletonDemo5@15db9742//s2
//反序列化读取对象后，发现是个新对象，破解了单例模式
testsingleton.SingletonDemo5@4c873330//s3
解决办法
- 实现serializable,添加readResolve()方法，使得在反序列换时返回已有对象，不需要再创建新的对象
package testsingleton;
import java.io.Serializable;
/**
* 测试懒汉式单例模式(如何防止反射和反序列化漏洞)
* 没有延迟加载
*
* @author 橙汁儿Drk
*
*/
public class SingletonDemo5 implements Serializable{
private static SingletonDemo5 instance;
private SingletonDemo5() {
}
public static synchronized SingletonDemo5 getInstance() {
if (instance null) {
instance = new SingletonDemo5();
}
return instance;
}
//反序列化时，如果定义了readResolve()方法则直接返回此方法指定的对象。而不需要再单独创建新对象
private Object readResolve() {
return instance;
}
}
多线程环境下测试单例模式的效率
-
五种单例模式在多线程下相对效率比较
饿汉式 22ms 懒汉式 636ms 静态内部类式 28ms 枚举式 32ms 双重检查锁式 65ms -
CountDownLatch类
- 同步辅助类，在完成一组正在给其他线程中执行操作之前，它允许一个或多个线程一直等待
countDown()当前线程调用此方法，则计数减一(建议放在finally里执行)await()调用此方法会抑制阻塞当前线程，知道计数器的值为0- 实例代码：
package testsingleton;
import java.util.concurrent.CountDownLatch;
/**
* 测试多线程环境下5种创建单例模式的效率
* @author 橙汁儿Drk
*
*/
public class Client3 {
public static void main(String[] args) throws Exception {
long start = System.currentTimeMillis();
//同步辅助类
int threadNum = 10;
CountDownLatch countDownLatch = new CountDownLatch(threadNum);
//线程
for(int i = 0;i<10;i++) {
new Thread(new Runnable() {
@Override
public void run() {
for(int i = 0;i<100000;i++) {
Object o = SingletonDemo3.getInstance();
}
//每执行完一个线程，计数器减一
countDownLatch.countDown();
}
}).start();;
}
countDownLatch.await();//main线程阻塞，直到计数器变为0，才会继续往下执行
long end = System.currentTimeMillis();
System.out.println("总耗时："+(end-start));
}
}