一、单例模式介绍
单例模式就是采取一定的方法保证在整个软件系统中,对某个类
只能存在一个对象实例
,并且该类只提供一个取得其对象实例的方法(静态方法)。
二、单例模式的八种方式:
- 1、饿汗式(静态常量)
- 2、饿汗式(静态代码块)
- 3、懒汉式(线程不安全)
- 4、懒汉式(线程安全,同步方法)
- 5、懒汉式(线程安全,同步代码块)
- 6、双重检查
- 7、静态内部类
- 8、枚举
三、饿汗式
(一)饿汗式(静态常量)
通常实现方法:
- 1、构造器私有化
- 2、类的内部创建对象
- 3、向外暴露一个静态的公共方法
- 4、代码实现
代码实现:
public class SingLeton{ //1.构造器私有化,外部可以new private SingLeton(){ } //2.本类的内部创建对象 private final static SingLeton singleton = new SingLeton(); //3.向外暴露一个静态的公共的方法 public static SingLeton getSingleton(){ return singleton; } }
测试代码:
package singleton.type1; public class SingletonTest01 { public static void main(String[] args) { //测试 SingLeton singLeton1 = SingLeton.getSingleton(); SingLeton singLeton2 = SingLeton.getSingleton(); //测试创建的两个是否相等 System.out.println(singLeton1 == singLeton2);//true //可以查看hashCode是否相同 System.out.println("singLeton1="+singLeton1.hashCode()); System.out.println("singLeton2="+singLeton2.hashCode()); } }
测试结果:
true singLeton1=1956725890 singLeton2=1956725890 Process finished with exit code 0
优缺点:
- 1、优点:这种写法比较简单,就是在类装载的时候就完成实例化。避免了线程同步问题。
- 2、缺点:在类装载的时候就完成实例化,没有达到懒加载的效果。
如果从开始到程序结束窦娥米使用这个实例,则会造成内存的浪费。
结论:
代码简单可以正常使用,但是可能会造成资源浪费。
欢迎关注我,一起创造奇迹;代码改变世界,一点也没有错。
(二)饿汗式(静态代码块)
相对于静态常量的方式只是把
final
常量给去掉了,然后再static{}
静态代码块中初始化。
代码实现:
package singleton.type2; public class SingLeton{ //1.构造器私有化,外部可以new private SingLeton(){ } //2.本类的内部创建对象 private static SingLeton singleton; //在静态代码块中创建单例模式 static { singleton = new SingLeton(); } //3.向外暴露一个静态的公共的方法 public static SingLeton getSingleton(){ return singleton; } }
测试:
package singleton.type2; public class SingletonTest02 { public static void main(String[] args) { //测试 SingLeton singLeton1 = SingLeton.getSingleton(); SingLeton singLeton2 = SingLeton.getSingleton(); //测试创建的两个是否相等 System.out.println(singLeton1 == singLeton2);//true //可以查看hashCode是否相同 System.out.println("singLeton1="+singLeton1.hashCode()); System.out.println("singLeton2="+singLeton2.hashCode()); } }
测试结果:
true singLeton1=1956725890 singLeton2=1956725890 Process finished with exit code 0
可以看到效果还是一样的。
优缺点:
- 1、这种方式和静态常量方式是相似的,只不过将类实例化的过程放在了静态代码块中,也是在类装载的时候,就执行静态代码块中的代码,初始化类的实例。优缺点都和静态常量的一样。
结论:
代码简单可以正常使用,但是可能会造成资源浪费。
四、懒汉式
(一)懒汉式(线程不安全)
通常实现方法:
- 在初始化的时候判断一下是否已经初始化,如果初始化了,就直接返回,否则就初始化,然后返回实例结果。
- 实际开发中,不推荐使用。
代码实现:
package singleton.type3; public class SingLeton { private static SingLeton singleton; private SingLeton(){ } //提供一个静态的共有方法,当使用到该方法时,才去创建singleton //就是所说的懒汉式,只有在使用的时候才会去创建对象 public static SingLeton getSingleton(){ if(singleton == null){ singleton = new SingLeton(); } return singleton; } }
测试代码:
package singleton.type3; public class SingletonTest03 { public static void main(String[] args) { //测试 System.out.println("懒汉式:"); SingLeton singLeton1 = SingLeton.getSingleton(); SingLeton singLeton2 = SingLeton.getSingleton(); //测试创建的两个是否相等 System.out.println(singLeton1 == singLeton2);//true //可以查看hashCode是否相同 System.out.println("singLeton1="+singLeton1.hashCode()); System.out.println("singLeton2="+singLeton2.hashCode()); } }
测试结果:
懒汉式: true singLeton1=1956725890 singLeton2=1956725890
优缺点:
- 1、起到了懒加载的效果(用到才会创建,用不到就不会创建),但是只能在单线程下使用;
- 2、如果在多线程下,一个线程进入了
if (singleton == null)
判断语句块,还未来得及往下执行,另一个线程也通过了这个判断语句,这时便会产生多个实例。所以在多线程环境下不能使用这种方式。
结论:
在实际开发中,不能使用这种方式,因为有潜在的风险。这种写法,就破坏了单利模式的原则了。
(二)懒汉式(线程安全,同步方法)
通常实现方法:
- 因为上面那个是线程不安全的,所以下面这个是为了改造上面的写法而诞生的。
- 在初始化方法中添加
synchronized
关键字;如果有多个需要执行的话,就不让其余的线程去执行了。- 这样的话,如果来了很多使用的人,就会排队一个一个执行,不会造成上面的情况。
代码实现:
package singleton.type4; /** * (二)、懒汉式(线程安全,同步方法) * 懒汉式的第二种写法,解决线程安全 */ public class SingLeton { private static SingLeton singleton; private SingLeton(){ } //提供一个静态的共有方法,加入同步处理的代码,解决线程安全问题 //懒汉式 public static synchronized SingLeton getSingleton(){ if(singleton == null){ singleton = new SingLeton(); } return singleton; } }
测试代码:
package singleton.type4; public class SingletonTest04 { public static void main(String[] args) { //测试 System.out.println("懒汉式:线程安全"); SingLeton singLeton1 = SingLeton.getSingleton(); SingLeton singLeton2 = SingLeton.getSingleton(); //测试创建的两个是否相等 System.out.println(singLeton1 == singLeton2);//true //可以查看hashCode是否相同 System.out.println("singLeton1="+singLeton1.hashCode()); System.out.println("singLeton2="+singLeton2.hashCode()); } }
测试结果:
懒汉式:线程安全 true singLeton1=1956725890 singLeton2=1956725890
优缺点:
- 1、解决了线程不安全问题
- 2、效率太低了,每个线程在想获得类的实例的时候,执行getXX()方法都要进行同步。其实这个方法只执行一次实例化代码就够了,后面在排队想获得该类实例的线程直接
return
就行了。方法进行同步效率太低。
结论:
在实际开发中效率太低了,不推荐使用这种方式。
(三)懒汉式(线程安全,同步代码块)
代码实现:
package singleton.type5; /** (三)、懒汉式(线程安全,同步代码块) */ public class SingLeton { private static SingLeton singleton; private SingLeton(){ } //懒汉式 public static SingLeton getSingleton(){ if(singleton == null){ synchronized (SingLeton.class){ singleton = new SingLeton(); } } return singleton; } }
优缺点:
- 1、这种写法的本意是想对第四种实现方式进行改进,因为前面同步方法效率太低,改为同步产生实例化的代码块。
- 2、
但是这种同步并不能起到线程永不的作用。
跟第三种实现方式遇到的情况是一样的,加入一个线程进入if
判断语句块,还未来得及往下执行,另一个线程也通过了这个判断语句,这时便会产生多个实例。
结论:
在实际开发中,不能使用这种方式。
五、双重检查(推荐使用)
推荐使用
可以解决:
- 1、可以解决线程安全的问题;
- 2、可以解决效率的问题;
- 3、懒加载也符合要求。
代码实现:
package singleton.type6; /** 五、双重检查(推荐使用) 推荐使用 */ public class SingLeton { //加上volatile关键字:可以让共享的变量达到共享的结果 private static volatile SingLeton singleton; private SingLeton(){ } //提供一个静态的共有方法,加入双重检查代码, // 解决了线程安全问题 // 解决了懒加载问题 // 保证了效率 public static SingLeton getSingleton(){ if(singleton == null){ synchronized (SingLeton.class){ /* 如果有A和B同时进入了这个代码块,那么假设A先进入了if代码块; 假设B后来了,走到if代码块的时候,发现类已经实例化了,就直接返回数据了 假设后面又来了C、D、E,那么根本就不会执行到这里,在第一层的if判断就被截止了,直接返回了 */ if(singleton==null) {//1:现在A进来了,为null; singleton = new SingLeton();//2:把类实例化,然后返回给A。 } } } return singleton; } }
测试代码:
package singleton.type6; /** * 五、双重检查(推荐使用) */ public class SingletonTest06 { public static void main(String[] args) { System.out.println("双重检查:"); SingLeton singLeton1 = SingLeton.getSingleton(); SingLeton singLeton2 = SingLeton.getSingleton(); //测试创建的两个是否相等 System.out.println(singLeton1 == singLeton2);//true //可以查看hashCode是否相同 System.out.println("singLeton1="+singLeton1.hashCode()); System.out.println("singLeton2="+singLeton2.hashCode()); } }
测试结果:
双重检查: true singLeton1=1956725890 singLeton2=1956725890
测试也是没有问题
优缺点:
- 1、Double-Check概念是多线程开发经常使用到的,如代码中所示,使用了两次
if(singleton==null)
检查,这样就可以保证了线程的安全。- 2、这样,实例化代码只用执行一次,后面再次访问时,判断
if(singleton==null)
,直接return
已经实例化的对象,也避免了重复进行方法同步。
结论:
保证了线程安全;延迟加载;效率较高;
在实际开发中,推荐使用这种方式。
六、静态内部类(推荐使用)
静态内部类特点:
- 1、当外部类被装载时,内部类并不会装载;
- 2、当外部类调用内部类的时候,才会装载,而且只会装载一次;而且在装载的时候是线程安全的,可以拿到懒加载的效果,同时是线程安全的;
代码实现:
package singleton.type7; /** 使用静态内部类完成单例模式 */ public class SingLeton { //加上volatile关键字:可以让共享的变量达到共享的结果 private static volatile SingLeton singleton; //构造器私有化 private SingLeton(){ } //静态内部类 /** * 好处:外部类在装载的时候,并不会直接装载这个内部类,从而保证了懒加载是可用的; * 只有来取的时候,才会被装载; */ private static class SingLetonInClass{ private static final SingLeton SING_LETON = new SingLeton(); } //提供一个静态的共有方法,直接返回`SingLetonInClass.SING_LETON` public static SingLeton getSingleton(){ return SingLetonInClass.SING_LETON; } }
测试代码:
package singleton.type7; /** * 使用静态内部类完成单例模式 */ public class SingletonTest07 { public static void main(String[] args) { System.out.println("使用静态内部类完成单例模式:"); SingLeton singLeton1 = SingLeton.getSingleton(); SingLeton singLeton2 = SingLeton.getSingleton(); //测试创建的两个是否相等 System.out.println(singLeton1 == singLeton2);//true //可以查看hashCode是否相同 System.out.println("singLeton1="+singLeton1.hashCode()); System.out.println("singLeton2="+singLeton2.hashCode()); } }
测试结果:
使用静态内部类完成单例模式: true singLeton1=1956725890 singLeton2=1956725890
测试也是没问题的
优缺点:
- 1、这种方式采用了类装载的机制来保证初始化实例时只有一个线程;
- 2、静态内部类方式在外部类
SingLeton
类被装载时,不会立即实例化。而是在需要实例化的时候,调用内部类的变了时,才会被装载,从而完成SingLeton
类的实例化;- 优点:避免了
线程不安全
,利用静态内部类特点实现延迟加载,效率高;
结论:
避免了
线程不安全
,利用静态内部类特点实现延迟加载,效率高;推荐使用;
七、枚举(推荐使用)
说明:
原先的一些问题,都可以使用枚举类来解决,用枚举类来实现单例模式还是比较好的。
代码实现:
package singleton.type8; //使用枚举类实现单例模式 enum SingLeton { SING_LETON;//属性 public void getInfoData(String name){ System.out.println("你好:"+name); } }
测试代码:
package singleton.type8; /** * 使用静态内部类完成单例模式 */ public class SingletonTest07 { public static void main(String[] args) { System.out.println("使用枚举类实现单例模式:"); SingLeton singLeton1 = SingLeton.SING_LETON; SingLeton singLeton2 = SingLeton.SING_LETON; //测试创建的两个是否相等 System.out.println(singLeton1 == singLeton2);//true //可以查看hashCode是否相同 System.out.println("singLeton1="+singLeton1.hashCode()); System.out.println("singLeton2="+singLeton2.hashCode()); } }
测试结果:
使用枚举类实现单例模式: true singLeton1=1956725890 singLeton2=1956725890
测试结果也是成功的;
优缺点:
- 使用枚举类的方式来实现单例模式,借助了JDK1.5中添加的枚举类来实现的。不仅能避免多线程同步问题,还能防止反序列化重新创建对象。
结论:
这种方式是Effective Java作者Josh Bloch提倡的方式;
推荐使用。
八、单例模式在JDK源码中使用的情形
在jdk源码中Runtime
就使用了单例模式来实现的
在 java.lang.Runtime中
打开Runtime.java的源码的话,可以看到包含一下代码:
public class Runtime { private static Runtime currentRuntime = new Runtime(); public static Runtime getRuntime() { return currentRuntime; } private Runtime() {} ...... }
代码分析:
- 1、构造方法是私有的:
private Runtime(){}
;- 2、变量是最初new出来的:
private static Runtime currentRuntime = new Runtime();
;- 3、只有用到的时候是使用get方法获取的:
getRuntime()
;
由以上分析过后,可以看出来是使用的饿汉式的单例实现模式来实现的。
九、总结
单例模式
:就是采取一定的方法保证在整个软件系统中,对某个类只能存在一个对象实例
,并且该类只提供一个
取得其对象实例的方法(静态方法)。
推荐使用的实现单例模式的方式:
- 枚举类
- 静态内部类
- 双重检查
- 饿汉式(可能会存在内存浪费)
单例模式注意事项和细节说明:
- 1、单例模式保证了系统内存中该类只存在一个对象,节省了系统资源,对于一些需要频繁创建销毁的对象,使用单例模式可以提高系统性能;
- 2、当想实例化一个单例类的时候,必须要记住使用相应的获取对象的方法,而不是使用new;
单利模式使用的场景:
- 1、需要频繁的进行创建和销毁的对象;
- 2、创建对象时耗时过多或消耗资源过多(重量级对象);
- 3、经常用到的对象、工具类对象、频繁访问数据库或文件的对象(比如:数据源、session工厂等)。