创建型--单例设计模式(Singleton pattern)
单例模式
- 核心作用：
- 保证一个类只有一个实例，并且提供一个访问该实例的全局访问点
- 常见应用场景
- 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内部，提高了执行的效率，不必每次获取对象时都进行同步，只有第一次同步创建了以后就没必要了。
- 问题：
-
- 单例对象要加volatile，防止指令重排
public class SingletonDemo03{
private static volatile SingletonDemo03 instance = null;
public static SingletonDemo03 getInstance(){
if(instance == null){
sychronized(SingletonDemo03.class){
if(sc == null){
sc = new SingletonDemo03();
}
}
}
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.INSTANCE==SingletonDemo4.INSTANCE);的结果为true
问题：
- 反射可以破解上面几种(不包括枚举式)实现方式！（可以在构造方法中手动抛出异常控制）
- 反序列化可以破解上面几种(不包括枚举式)实现方式！
-
- 可以通过定义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));
}
}