• 核心作用:
– 保证一个类只有一个实例,并且提供一个访问该实例的全局访问点。
• 常见应用场景:
– Windows的Task Manager(任务管理器)就是很典型的单例模式
– windows的Recycle Bin(回收站)也是典型的单例应用。在整个系统运行过程中,回收站一直维护着仅有的一个实例。 – 项目中,读取配置文件的类,一般也只有一个对象。没有必要每次使用配置文件数据,每次new一个对象去读取。 – 网站的计数器,一般也是采用单例模式实现,否则难以同步。 – 应用程序的日志应用,一般都何用单例模式实现,这一般是由于共享的日志文件一直处于打开状态,因为只能有一个实例去操作,否则内容不好追加。 – 数据库连接池的设计一般也是采用单例模式,因为数据库连接是一种数据库资源。 – 操作系统的文件系统,也是大的单例模式实现的具体例子,一个操作系统只能有一个文件系统。 – Application 也是单例的典型应用(Servlet编程中会涉及到) – 在Spring中,每个Bean默认就是单例的,这样做的优点是Spring容器可以管理 – 在servlet编程中,每个Servlet也是单例 – 在spring MVC框架/struts1框架中,控制器对象也是单例• 单例模式的优点:
– 由于单例模式只生成一个实例,减少了系统性能开销,当一个对象的产生需要比较多的资源时,如读取配置、产生其他依赖 对象时,则可以通过在应用启动时直接产生一个单例对象,然后永久驻留内存的方式来解决
– 单例模式可以在系统设置全局的访问点,优化环共享资源访问,例如可以设计一个单例类,负责所有数据表的映射处理• 常见的五种单例模式实现方式:
– 主要:
• 饿汉式(线程安全,调用效率高。 但是,不能延时加载。) • 懒汉式(线程安全,调用效率不高。 但是,可以延时加载。) – 其他: • 双重检测锁式(由于JVM底层内部模型原因,偶尔会出问题。不建议使用) • 静态内部类式(线程安全,调用效率高。 但是,可以延时加载)• 枚举单例(线程安全,调用效率高,不能延时加载)
• 饿汉式实现(单例对象立即加载)
1 public class SingletonDemo { 2 private static /*final*/ SingletonDemo s = new SingletonDemo(); 3 private SingletonDemo(){} // 私有化构造器 4 public static /*synchronized*/ SingletonDemo getInstance() { 5 return s; 6 } 7 } 8 9 public class Client {10 public static void main(String[] args) {11 SingletonDemo s = SingletonDemo.getInstance();12 SingletonDemo s2 = SingletonDemo.getInstance();13 System.out.println(s==s2); //结果为true14 }15 }
– 饿汉式单例模式代码中,static变量会在类装载时初始化,此时也不会涉及多个线程对象访问该对象的问题。虚拟机保证只会装载一次该类,肯定不会发生并发访问的问题。因此,可以省略synchronized关键字。
– 问题:如果只是加载本类,而不是要调用getInstance(),甚至永远没有调用,则会造成资源浪费!
• 懒汉式实现(单例对象延迟加载)
1 public class SingletonDemo { 2 private static SingletonDemo s; 3 private SingletonDemo(){} // 私有化构造器 4 public static synchronized SingletonDemo getInstance() { 5 if(s==null) { 6 s = new SingletonDemo(); 7 } 8 return s; 9 }10 }11 12 public class Client {13 public static void main(String[] args) {14 SingletonDemo s = SingletonDemo.getInstance();15 SingletonDemo s2 = SingletonDemo.getInstance();16 System.out.println(s==s2); //结果为true17 }18 }
- lazy load! 延迟加载, 懒加载! 真正用的时候才加载!
- 问题:资源利用率高了。但是,每次调用getInstance()方法都要同步,并发效率较低。• 双重检测锁实现
1 public class SingletonDemo { 2 private static SingletonDemo instance = null; 3 public static SingletonDemo getInstance() { 4 if (instance == null) { 5 SingletonDemo sc; 6 synchronized (SingletonDemo.class) { 7 sc = instance; 8 if (sc == null) { 9 synchronized (SingletonDemo.class) {10 if(sc == null) {11 sc = new SingletonDemo();12 }13 }14 instance = sc;15 }16 }17 }18 return instance;19 }20 private SingletonDemo() {}21 }22 23 public class Client {24 public static void main(String[] args) {25 SingletonDemo s = SingletonDemo.getInstance();26 SingletonDemo s2 = SingletonDemo.getInstance();27 System.out.println(s==s2); //结果为true28 }29 }
– 这个模式将同步内容下方到if内部,提高了执行的效率不必每次获取对象时都进行同步,只有第一次才同步创建了以后就没必要了。
– 问题:由于编译器优化原因和JVM底层内部模型原因,偶尔会出问题。不建议使用。
• 静态内部类实现方式(也是一种懒加载方式)
1 public class SingletonDemo { 2 private static class SingletonClassInstance { 3 private static final SingletonDemo instance = new SingletonDemo(); 4 } 5 public static SingletonDemo getInstance() { 6 return SingletonClassInstance.instance; 7 } 8 private SingletonDemo() {} 9 }10 public class Client {11 public static void main(String[] args) {12 SingletonDemo s = SingletonDemo.getInstance();13 SingletonDemo s2 = SingletonDemo.getInstance();14 System.out.println(s==s2); //结果为true15 }16 }
• 要点:
– 外部类没有static属性,则不会像饿汉式那样立即加载对象。 – 只有真正调用getInstance(),才会加载静态内部类。加载类时是线程 安全的。instance是static final类型,保证了内存中只有这样一个实例存在,而且只能被赋值一次,从而保证了线程安全性.– 兼备了并发高效调用和延迟加载的优势!
• 问题:
– 反射可以破解上面几种(不包含枚举式)实现方式!(可以在构造方法中手动抛出异常控制)– 反序列化可以破解上面几种(不包含枚举式)实现方式!可以通过定义readResolve()防止获得不同对象,反序列化时,如果对象所在类定义了readResolve()(实际是一种回调),定义返回哪个对象。
1 /** 2 * 使用反射和反序列化破解单例模式 3 */ 4 public class Client { 5 public static void main(String[] args) { 6 //通过反射的方式直接调用私有构造器 7 Classclazz = (Class ) Class.forName("com.singleton.SingletonDemo"); 8 Constructor c = clazz.getDeclaredConstructor(null); 9 c.setAccessible(true);10 SingletonDemo s1 = c.newInstance();11 SingletonDemo s2 = c.newInstance();12 System.out.println(s1);13 System.out.println(s2);14 15 //通过反序列化的方式构造多个对象16 SingletonDemo s3 = SingletonDemo.getInstance();17 SingletonDemo s4 = SingletonDemo.getInstance();18 System.out.println(s3);19 System.out.println(s4);20 FileOutputStream fos = new FileOutputStream("d:/a.txt");21 ObjectOutputStream oos = new ObjectOutputStream(fos);22 oos.writeObject(s3);23 oos.close();24 fos.close();25 ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d:/a.txt"));26 SingletonDemo s5 = (SingletonDemo) ois.readObject();27 System.out.println(s5);28 }29 }30 31 /**32 * 防止使用反射和反序列化破解单例模式33 */34 public class SingletonDemo implements Serializable {35 36 private static SingletonDemo s;37 38 //私有化构造器39 40 private SingletonDemo() throws Exception {41 if(s!=null) {42 43 // 通过手动抛出异常,避免通过反射创建多个单例对象!44 45 throw new Exception(" 只能创建一个对象");46 }47 } 48 public static synchronized SingletonDemo getInstance() throws Exception {49 if(s==null) {50 s = new SingletonDemo();51 }52 return s;53 }54 // 反序列化时,如果对象所在类定义了readResolve() ,(实际是一种回调),定义返回哪个对象。55 private Object readResolve() throws ObjectStreamException {56 return s;57 }58 }
• 使用枚举实现单例模式
1 public enum SingletonDemo { 2 /** 3 * 定义一个枚举的元素,它就代表了Singleton 的一个实例。 4 */ 5 INSTANCE; 6 /** 7 * 单例可以有自己的操作 8 */ 9 public void singletonOperation(){10 // 功能处理11 }12 }13 14 public static void main(String[] args) {15 SingletonDemo s1 = SingletonDemo.INSTANCE;16 SingletonDemo s2 = SingletonDemo.INSTANCE;17 System.out.println(s1==s2);18 }
• 优点:
– 实现简单 – 枚举本身就是单例模式。由JVM从根本上提供保障!避免通过反射和反序列化的漏洞! • 缺点: – 无延迟加载