一、什么是单例模式
单例模式(Singleton Pattern)是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。
这种模式涉及到一个单一的类,该类负责创建自己的对象,同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式,可以直接访问,不需要实例化该类的对象。
需要注意:
1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。
实现说明:
1、私有化该类的构造方法,构造方法私有化,其他的类或代码无法通过调用该类的构造方法来实现该类,必须通过调用该类提供的静态方法实例化方法来实例化。
2、该类提供一个静态的实例化自己的方法,如果该类已经实例化,就直接提供实例化的引用,如果没有实例化,就创建一个实例化引用,并赋予该类保持的引用。
下面是单例模式的结构图:
二、单例模式的优点和缺点
优点:
1、单例模式可以保证内存里只有一个实例,减少了内存的开销。
2、可以避免对资源的多重占用。
3、单例模式设置全局访问点,可以优化和共享资源的访问。
缺点:
1、单例模式一般没有接口,扩展困难。如果要扩展,则除了修改原来的代码,没有第二种途径,违背开闭原则。
2、在并发测试中,单例模式不利于代码调试。在调试过程中,如果单例中的代码没有执行完,也不能模拟生成一个新的对象。
3、单例模式的功能代码通常写在一个类中,如果功能设计不合理,则很容易违背单一职责原则。
三、单例模式的应用场景
在计算机系统中,有 Windows 的回收站、操作系统中的文件系统、多线程中的线程池、显卡的驱动程序对象、打印机的后台处理服务、应用程序的日志对象、数据库的连接池、网站的计数器、Web 应用的配置对象、应用程序中的对话框、系统中的缓存等常常被设计成单例。
适用场景:
1.需要生成唯一序列的环境
2.需要频繁实例化然后销毁的对象。
3.创建对象时耗时过多或者耗资源过多,但又经常用到的对象。
4.方便资源相互通信的环境
二、多种方式实现单例
1、懒汉方式
在类初始化的时候就不会实例化,只有在需要的时候才会实例化一个引用。
方法实现:
/** * 懒汉单例方式 */ public class LazySingleton { /** * 添加 volatile 是保证在线程中同步 */ private static LazySingleton instance = null; /** * 私有化无参构造 */ private LazySingleton(){ } /** * 加synchronized 也是为了线程安全 */ public static LazySingleton getInstance(){ if(instance == null){ instance = new LazySingleton(); } return instance; } }
测试类:
public static void main(String[] args) throws Exception { //ptMethod(); //fsMethod(); threadDemo(); } /** * 普通方法 */ public static void ptMethod(){ System.out.println("普通方法!"); LazySingleton la1 = LazySingleton.getInstance(); LazySingleton la2 = LazySingleton.getInstance(); System.out.println(la1==la2); } /** * 反射 */ public static void fsMethod() throws Exception{ System.out.println("反射方法!"); Class<LazySingleton> cl = LazySingleton.class; Constructor<LazySingleton> cla = cl.getDeclaredConstructor(); cla.setAccessible(true); LazySingleton la1 = LazySingleton.getInstance(); LazySingleton la2 = cla.newInstance(); System.out.println(la1== la2); } /** * 多线程 */ private static void threadDemo(){ System.out.println("多线程"); for (int i = 0; i < 5; i++) { new Thread(){ @Override public void run() { System.out.println(LazySingleton.getInstance()); } }.start(); } }
执行结果:
普通方法:
反射方法:
多线程方法:
结论:
从上面的测试代码中可以看出,懒汉方式在普通方法中调用是线程安全的,用反射调用是非线程安全的,多线程也是不安全的。解决线程不安全的办法就是在创建静态对象参数的时候添加volatile ,并且在静态实例化方法上添加synchronized 来实现线程安全。(上面的代码中也已经标注出来了)
2、饿汉方式
在类初始化的时候就会先被实例化,但是如果一直不用就会占着一部分内存。
方法实现:
public class HungrySingleton { /** * 创建实体类 */ private static HungrySingleton instance = new HungrySingleton(); /** * 私有化构造方法 */ private HungrySingleton(){} /** * 静态对外方法 * @return */ public static HungrySingleton getInstance(){ return instance; } }
测试类:
public class Test2 { public static void main(String[] args) throws Exception{ //ptMethod(); //fsMethod(); threadDemo(); } /** * 普通方法 */ public static void ptMethod(){ System.out.println("普通方法!"); HungrySingleton hs1 = HungrySingleton.getInstance(); HungrySingleton hs2 = HungrySingleton.getInstance(); System.out.println(hs1==hs2); } /** * 反射 */ public static void fsMethod() throws Exception{ System.out.println("反射方法!"); Class<HungrySingleton> cl = HungrySingleton.class; Constructor<HungrySingleton> cla = cl.getDeclaredConstructor(); cla.setAccessible(true); HungrySingleton hs1 = HungrySingleton.getInstance(); HungrySingleton hs2 = cla.newInstance(); System.out.println(hs1== hs2); } /** * 多线程 */ private static void threadDemo(){ System.out.println("多线程"); for (int i = 0; i < 5; i++) { new Thread(){ @Override public void run() { System.out.println(HungrySingleton.getInstance()); } }.start(); } } }
执行结果:
普通方法:
反射方法:
线程方法:
总结:
饿汉方式普通调用是线程安全的,反射调用不安全,线程调用是安全的,并且不用加锁,执行效率高,但容易产生垃圾对象。
3、登记方式
/** * 登记方式 */ public class RegisterSingleton { private static class RegisterSingletonHodel{ private static RegisterSingleton instance = new RegisterSingleton(); } private RegisterSingleton(){} public static RegisterSingleton getInstance(){ return RegisterSingletonHodel.instance; } }
测试类:
public class Test3 { public static void main(String[] args) throws Exception{ ptMethod(); //fsMethod(); //threadDemo(); } /** * 普通方法 */ public static void ptMethod(){ System.out.println("普通方法!"); RegisterSingleton rs1 = RegisterSingleton.getInstance(); RegisterSingleton rs2 = RegisterSingleton.getInstance(); System.out.println(rs1==rs2); } /** * 反射 */ public static void fsMethod() throws Exception{ System.out.println("反射方法!"); Class<RegisterSingleton> cl = RegisterSingleton.class; Constructor<RegisterSingleton> cla = cl.getDeclaredConstructor(); cla.setAccessible(true); RegisterSingleton rs1 = RegisterSingleton.getInstance(); RegisterSingleton rs2 = cla.newInstance(); System.out.println(rs1== rs2); } /** * 多线程 */ private static void threadDemo(){ System.out.println("多线程"); for (int i = 0; i < 5; i++) { new Thread(){ @Override public void run() { System.out.println(RegisterSingleton.getInstance()); } }.start(); } } }
普通方法:
反射方法:
线程方法:
总结:登记方式和懒汉方式加双重锁效果一样,它可以延迟加载,而且不会浪费内存资源,线程也是安全的,反射不安全。
4、枚举方式
/** * 枚举方式 */ public enum EnumSingleton { INSTANCE; public void whateverMethod(){ System.out.println("枚举方式"); } }
测试类:
public class Test4 { public static void main(String[] args) throws Exception{ // ptMethod(); fsMethod(); } /** * 普通方法 */ public static void ptMethod(){ System.out.println("普通方法!"); EnumSingleton es1 = EnumSingleton.INSTANCE; EnumSingleton es2 = EnumSingleton.INSTANCE; System.out.println(es1==es2); } /** * 反射 */ public static void fsMethod() throws Exception{ System.out.println("反射方法!"); Class<EnumSingleton> cl = EnumSingleton.class; Constructor<EnumSingleton> cla = cl.getDeclaredConstructor(); cla.setAccessible(true); EnumSingleton rs1 = EnumSingleton.INSTANCE; EnumSingleton rs2 = cla.newInstance(); System.out.println(rs1== rs2); } }
普通方法:
反射方法:
总结:枚举方式不仅能避免多线程同步问题,而且还自动支持序列化机制,防止反序列化重新创建新的对象,绝对防止多次实例化,并且不能通过反射来调用,唯一的缺点就是不能被继承。
三、最后总结
总的来说在一般情况下,不建议使用懒汉方式,如果有特殊的需求可以选择用加双重校验锁的方式来应用,推荐用还是饿汉方式,虽然初始化的时候回占用一定的内存,但是效率高,线程安全;如果涉及到延迟加载可以使用登记方式;如果涉及到反序列化创建对象时可尝试使用枚举方式。