单例模式

置顶还不是为了赚点窝囊费

于 2020-06-07 17:41:22 发布

阅读量250

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/xxwn446/article/details/106604641

版权

java 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

单例模式：保证一个类仅有一个实例对象，并且提供一个访问它的全局访问点。
单例模式的6种写法：
1.饿汉模式：
public class SingleTon{

private static SingleTon instance = new SingleTon（）；  
private SingleTon（）；   
public static SingleTon getInstance（）{  
return instance;
    
}

}
优点：加载时就完成了类的初始化，所以类的加载较慢，但是获取对象的速度较快，这种方式基于累的加载机制，避免了多线程的同步问题。
缺点：在类的加载的时候就完成了初始化，没有达到懒加载的效果，如果从始至终这个对象没有被使用，就会造成内存浪费。

2.懒汉模式（线程不安全）：
public class SingleTon{

private static SingleTon instance ；  
private SingleTon（）{}  
public static SingleTon getInstance（）{    
  
  if（instance==null）{  
  instance = new SingleTon();  
      
  }
    return instance;  
    
}

}

优点：实现了对象的延迟加载。
缺点：线程不安全。
3.懒汉模式（线程安全的懒汉模式）：
public class SingleTon{

private static SingleTon instance ；  
private SingleTon（）{}  
public static synchronized SingleTon getInstance（）{    
  
  if（instance==null）{  
  instance = new SingleTon();  
      
  }
    return instance;  
    
}

}
优点:做到了延迟加载，线程安全。
缺点：每次调用getInstance（）方法的时候，都需要进行同步，造成不必要的同步开销，而且大多数用不到同步，所以不建议使用这种模式。
4.双重检查模式（DCL）:
public class SingleTon{

private volatile static SingleTon instance;   
    private SingleTon(){}  
    public static SingleTon getInstance(){  
        if(instance == null){      
           synchronized(SingleTon.class){    
           if(instance == null){    
               instance = new SingleTon();
               
              }
               
           }
        
        }  
        return instance;
    }

}
双重检查两次判空：考虑到这样一种情况，假如说有两个线程同时到达，即同时调用getInstance（）方法，由于此时instance == null，所以，两个线程都可以通过第一重的instance == null，进入第一重的if语句之后，由于存在synchronized机制，所以会有一个线程进入lock语句，并进入第二重的instance == null，而另外一个线程则在loc语句外面等待，当第一个线程执行完new SingleTon()语句之后，便会推出锁定区域，此时，第二个线程便可以进入lock语句块，此时如果没有第二重instance == null，那么第二个线程还是可以调用new SingleTon()语句，这样第二个线程也会创建一个SingleTon对象，这样就违背了单例模式的初衷，所以这里必须使用双重检查。
假如程序中没有第一重instance == null，当有两个线程同时到达时，此时，由于存在lock机制，第一个线程会进入lock语句块，并且可以顺利创建对象，当第一个线程退出lock语句块时，instance已经不为空，所以当第二个线程进入lock语句块时，还是会被第二重的instance == null挡在外面，无法创建对象。所以在没有第一重的instance == null的情况下也是可以实现单例模式的，那么为什么需要第一重instance == null呢？这里涉及到的是性能问题，因为对于单例模式new SingleTon（）只需要执行一次就可以了，而如果没有第一重instance == null的话，每次有线程进入getInstance（）方法时，均会执行锁定操作来实现线程同步，这是非常耗费性能的，如果加上第一重instance == null的话，只有在第一次，也就是instance == null成立时的情况下执行一次锁定以实现线程同步，以后直接返回instance对象就可以了，无需再进入lock语句块，这样就解决了线程同步带来的性能问题。

volatile：

优点：资源利用率高，减少多余的线程同步问题。

缺点：某些情况下会出现DCL失效问题。这里建议使用静态内部类单例模式代替DCL
5.静态内部类单例模式：
public class SingleTon{
private SingleTon（）{}
public static SingleTon getInstance（）{ return SingleTonHolder.instance;

}  
private static class SingleTonHolder{  
    private static final SingleTon instance = new SingleTon();
}

}
优点：只有第一次调用getInstance方法时虚拟机加载SingleTonHolder并初始化instance，不仅能保证线程安全，也能保证SingleTon类的唯一性，推荐使用静态内部了你单例模式。
6.枚举单例
public enum SingleTon{
INSTANCE; public void doSomeThing(){

}
优点：简单，线程安全
缺点：可读性不高
在上面讲的几种单例模式中，有一种情况下会重新创建对象，那就是反序列化：将一个单例实例对象写到磁盘中在读回来，从而获得了一个事例。反序列化操作提供了readResolve方法，这个方法可以控制对象的反序列化，早上述几个方法示例中，如果要杜绝对象被反序列化时重新生成对象，就必须加入下面的方法
private Object readResolve() throws ObjectStreamException{
return instance; }
单例模式使用场景：在一个系统中，要求一个类有且仅有一个对象，使用场景如下：
（1）整个项目需要一个共享访问点或者共享数据。（2）创建一个对象需要耗费资源过多，比如数据库资源。
（3）工具类对象。