概述
- 所谓类的单例设计模式,就是采取一定的方法保证在整个的软件系统中,对某个类只能存在一个对象实例,并且该类只提供一个取得其对象实例的方法(静态方法)。
饿汉式(方法一:静态变量)
- 基本步骤:
《1》构造器私有化(防止new)
《2》类的内部创建对象
《3》向外暴露一个静态的公共方法(getInstance()方法) - 代码实现
package com.design;
public class SingletonTest01 {
public static void main(String[] args) {
Singleton singleTon = Singleton.getInstance();
Singleton singleTon2 = Singleton.getInstance();
System.out.println(singleTon==singleTon2);
}
}
//饿汉式(静态变量)
class Singleton{
//1.构造器私有化
private Singleton(){
}
//2.本类内部创建对象实例
private final static Singleton instance =new Singleton();
//3.提供一个公有的静态方法,返回实例对象
public static Singleton getInstance(){
return instance;
}
}
- 优缺点分析
《1》优点:这种写法比较简单,就是在类装载的时候就完成实例化。避免了线程同步问题。
《2》缺点:在类装载的时候就完成实例化,没有达到Lazy Loading的效果。如果从始至终从未使用这个实例,则会造成内存的浪费。
《3》这种方式基于classloder机制避免了多线程的同步问题,但是,instance在类装载时就实例化,在单例模式中大多数都是调用getInstance()方法,但是导致类装载的原因有很多种,因此不能确定有其他方式(或者其他的静态方法)导致类装载,这时候初始化instance没有达到lazy loading的效果
《结论》这种单例模式可用,可能造成内存浪费
饿汉式(方法二:静态代码块)
package com.design;
public class SingletonTest02 {
public static void main(String[] args) {
Singleton singleTon = Singleton.getInstance();
Singleton singleTon2 = Singleton.getInstance();
System.out.println(singleTon==singleTon2);
}
}
//饿汉式(静态变量)
class Singleton2{
//1.构造器私有化
private Singleton2(){
}
//2.本类内部创建对象实例
private static Singleton2 instance ;
//在静态代码块中创建对象
static{
instance =new Singleton2();
}
//3.提供一个公有的静态方法,返回实例对象
public static Singleton2 getInstance(){
return instance;
}
}
- 分析
《1》这种方式和上面的方式其实类似,只不过将类实例化放在了静态代码块中,也是在类装载的时候,就执行静态代码块中的代码,初始化类的实例。优缺点和上面一种方式是一样的。
《2》结论:这种单例模式可用,但是可能造成内存浪费
懒汉式(方法一:线程不安全方式)
package com.design;
public class SingletonTest03 {
public static void main(String[] args) {
Singleton3 singleTon = Singleton3.getInstance();
Singleton3 singleTon2 = Singleton3.getInstance();
System.out.println(singleTon==singleTon2);
}
}
//饿汉式(静态变量)
class Singleton3{
//1.构造器私有化,防止别人new
private Singleton3(){
}
//2.本类内部定义对象实例
private static Singleton3 instance ;
//3.提供一个公有的静态方法,当使用到该方法是时才去创建对象,
//返回实例对象,即懒汉式,不会造成内存浪费
public static Singleton3 getInstance(){
if(instance==null){
instance =new Singleton3();
}
return instance;
}
}
- 分析:
《1》线程不安全的,起到了Lazy loading的效果,在需要用的时候才创建对象,但是只能在单线程下使用
《2》如果在多线程下,一个线程进入了if(singleton==null)判断语句块,还未来得及往下执行,另外一个线程也通过了这个判断语句,这时便会产生多个实例。所以在多线程环境下不可使用这种方式。
《3》结论:在实际开发中,不要使用这种方式。
懒汉式(方法二:线程安全,同步方法)
package com.design;
//懒汉式:线程安全方式
public class SingletonTest04 {
public static void main(String[] args) {
Singleton3 singleTon = Singleton3.getInstance();
Singleton3 singleTon2 = Singleton3.getInstance();
System.out.println(singleTon==singleTon2);
}
}
//饿汉式(静态变量)
class Singleton4{
//1.构造器私有化,防止别人new
private Singleton4(){
}
//2.本类内部定义对象实例
private static Singleton4 instance ;
//3.提供一个公有的静态方法,当使用到该方法是时才去创建对象,
//返回实例对象,即懒汉式,不会造成内存浪费
//加入了同步处理代码,解决上述线程不安全问题
public static synchronized Singleton4 getInstance(){
if(instance==null){
instance =new Singleton4();
}
return instance;
}
}
- 分析:
《1》解决了线程不安全问题
《2》效率太低了,每个线程在想获得类的实例时候,执行getInstance()方法都要进行同步。而其实这个方法只执行了一次实例化代码就够了,后面的想获得该类实例,直接return就行了。方法进行同步效率太低
《3》结论:在实际开发中,不推荐使用这种方式
懒汉式(方法三:同步代码块,很不靠谱)
package com.design;
//懒汉式:线程安全方式,同步代码块,还是不靠谱
public class SingletonTest05 {
public static void main(String[] args) {
Singleton5 singleTon = Singleton5.getInstance();
Singleton5 singleTon2 = Singleton5.getInstance();
System.out.println(singleTon==singleTon2);
System.out.println(singleTon.hashCode()==singleTon2.hashCode());
}
}
//饿汉式(静态变量)
class Singleton5{
//1.构造器私有化,防止别人new
private Singleton5(){
}
//2.本类内部定义对象实例
private static Singleton5 instance ;
//3.提供一个公有的静态方法,当使用到该方法是时才去创建对象,
public static synchronized Singleton5 getInstance(){
if(instance==null){
synchronized(Singleton.class){
instance =new Singleton5();
}
}
return instance;
}
}
- 分析
《1》这种方式,本意是相对第四种实现方式的改进,因为前面同步方法效率太低,改为同步产生实例化的代码块
《2》***但是这种同步并不能起到线程同步的作用。***跟第三种方式遇到的情形一致,假如一个线程进入了if(Singleton==null),还未来得及向下执行,另一个线程通过了这个判断语句,这时便会产生多个实例
《3》结论:在实际开发中,不能使用这种方式
双重检查(推荐使用,线程安全,效率高)
package com.design;
//懒汉式:线程安全方式,双重检查方式
public class SingletonTest06 {
public static void main(String[] args) {
Singleton6 singleTon = Singleton6.getInstance();
Singleton6 singleTon2 = Singleton6.getInstance();
System.out.println(singleTon==singleTon2);
System.out.println(singleTon.hashCode()==singleTon2.hashCode());
}
}
//饿汉式(静态变量)
class Singleton6{
//1.构造器私有化,防止别人new
private Singleton6(){
}
//2.本类内部定义对象实例
//达到一定的同步效果
private static volatile Singleton6 instance ;
//双重检查方式,解决线程安全问题,同时解决懒加载问题,同时保证效率
//推荐使用
public static synchronized Singleton6 getInstance(){
if(instance==null){
synchronized(Singleton6.class){
if(instance==null){
instance =new Singleton6();
}
}
}
return instance;
}
}
- 分析
《1》双重检查是多线程开发中常使用到的,如代码中所示,我们进行了两次f(singleton==null)检查,这样就可以保证线程安全了
《2》实例化代码只用执行一次,后面再第一次判断完就可以继续使用,避免了反复的整个代码同步,提高了效率
《3》线程安全,延迟加载(懒加载,用的时候才加载),效率较高
《4》结论:在实际开发中,推荐使用这种单例模式
静态内部类
- 特点:外部类装载时,静态内部类不会被装载;当使用静态内部类时才会被装载。达到懒加载和线程安全。
package com.design.danli;
//静态内部类----单例模式
public class SingletonTest07 {
public static void main(String[] args) {
Singleton7 singleTon = Singleton7.getInstance();
Singleton7 singleTon2 = Singleton7.getInstance();
System.out.println(singleTon==singleTon2);
System.out.println(singleTon.hashCode()==singleTon2.hashCode());
}
}
class Singleton7{
//好处,外部类装载并不会造成内部类装载,保证懒加载
//用的时候装载,JVM在装载类的时候是线程安全的
//构造器私有化,防止别人new
private Singleton7(){}
//写一个静态内部类
private static class SingletonInstance{
private static final Singleton7 INSTANCE=new Singleton7();
}
public static synchronized Singleton7 getInstance(){
return SingletonInstance.INSTANCE;
}
}
- 优缺点分析:
《1》这种方式采用了类装载的机制来保证初始化实例只有一个线程
《2》静态内部类方式在Singleton类被装载时并不会立即实例化,而是在需要实例化时,调用getInstance方法,才会装载SingletonInstance类,从而完成Singleton的实例化
《3》类的静态属性只会在第一次加载类的时候初始化,所以在这里,JVM帮助我们保证了线程的安全性,在类进行初始化时,别的线程是无法进入的。
《4》优点:避免了线程不安全,利用静态内部类特点实现延迟加载,效率高
《结论》:推荐使用
枚举实现
package com.design.danli;
//枚举实现单例模式
public class SingletonTest08 {
public static void main(String[] args) {
Singleton8 instance =Singleton8.INSTANCE;
Singleton8 instance2 =Singleton8.INSTANCE;
System.out.println(instance==instance2);
System.out.println(instance.hashCode()==instance2.hashCode());
instance.sayOk();
}
}
//使用枚举,可以实现单例,推荐使用
enum Singleton8{
INSTANCE;//属性
public void sayOk(){
System.out.println("ok~");
}
}
- 优缺点说明
《1》这借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题,而且还能防止反序列化重新创建新的对象。
《2》这种方式是Effective Java作者Josh Bloch提倡的方式
《3》结论:推荐使用
单例模式在JDK应用的源码分析
- 我们JDK中,java.lang.Runtime就是经典的单例模式【饿汉式:静态变量】
总结
- 单例模式保证了系统内存中该类只存在一个对象,节省了系统资源,对于**一些需要频繁创建销毁的对象,**使用单例模式可以提高系统性能。
- 当想实例化一个单例类的时候,必须要记住使用相应的获取对象的方法,而不是使用new
- 单例模式的使用场景:需要频繁的进行创建和销毁的对象、创建对象时耗时过多或者耗费资源过多(即:重量级对象),但又经常用到的对象,工具类对象,频繁访问数据库或文件的对象(比如:数据源、session工厂等)
重要的推荐使用的
- 饿汉式(静态常量)(确定对象一定会用到一次)
- 饿汉式(静态代码块)(确定对象一定会用到一次)
- 双重检查
- 静态内部类
- 枚举