Java单例模式的知识点详解
懒汉模式与饿汉模式
懒汉模式就是懒加载，用到的时候去加载，存在线程安全问题，需要手动地加锁控制。它的优点是类加载的速度比较快，按需加载，节省资源。
饿汉模式就是在类加载的时候会创建出实例。它天生就不存在线程安全问题。但是类加载的速度会变慢且耗费资源。
懒汉模式-单重检查
示例代码如下：
publicclassLazySingleton{
privatestaticLazySingletonsingletoninstance=null;
privateObjectdata=newObject();
//私有化构造方法
privateLazySingleton(){
}
//加锁访问
publicstaticsynchronizedLazySingletongetInstance(){
if(singletoninstance==null){
singletoninstance=newLazySingleton();
}
returnsingletoninstance;
}
publicObjectgetData(){
returndata;
}
publicvoidsetData(Objectdata){
this.data=data;
}
}
测试代码如下：
publicclassTestThreadextendsThread{
@Override
publicvoidrun(){
LazySingletoninstance=LazySingleton.getInstance();
System.out.println(instance.getData());
}
}
publicstaticvoidmain(String[]args){
for(inti=0;i<10;i++){
TestThreadt=newTestThread();
t.start();
}
}
}
运行结果如下：
java.lang.Object@306d3b64
java.lang.Object@306d3b64
java.lang.Object@306d3b64
java.lang.Object@306d3b64
java.lang.Object@306d3b64
java.lang.Object@306d3b64
java.lang.Object@306d3b64
java.lang.Object@306d3b64
java.lang.Object@306d3b64
java.lang.Object@306d3b64
打印出同一个object对象，表明是从同一个LazySingleton对象中获取的数据。
但是上述代码存在一个显著的问题：多个线程同时访问getInstance()方法都是排队式的，即使该instance已经被创建的情况下。然而，如果该instance已经被创建，是可以支持并发访问的。需要对锁的控制细粒度化。
懒汉模式-双重检查
publicclassLazySingleton{
//声明为volatile变量
privatestaticvolatileLazySingletonsingletoninstance=null;
privateObjectdata=newObject();
privateLazySingleton(){
}
publicstaticsynchronizedLazySingletongetInstance(){
if(singletoninstance==null){
synchronized(LazySingleton.class){
//这个第二重的的检查是必要的
if(singletoninstance==null)
singletoninstance=newLazySingleton();
}
}
returnsingletoninstance;
}
publicObjectgetData(){
returndata;
}
publicvoidsetData(Objectdata){
this.data=data;
}
}
第二重检查是为了防止：
线程A发现instance未被创建，于是申请锁，进入临界区创建instance；于此同时另一个线程也发现instance未被创建，于是也要申请锁去创建instance，问题就这样发生了。而且，这个instance变量要被声明为volatile，也就是其中一个线程对它就行修改之后（也就是实例化），这一修改立马对其他线程可见，避免了无谓的等待。
检查代码同上，运行结果同上。
饿汉模式
publicclassHungerSingleton{
privatestaticfinalHungerSingletonsingletoninstance=newHungerSingleton();
privateObjectdata=newObject();
privateHungerSingleton(){
}
publicstaticHungerSingletongetInstance(){
returnsingletoninstance;
}
publicObjectgetData(){
returndata;
}
publicvoidsetData(Objectdata){
this.data=data;
}
}
在加载该类的时候就立马去实例化instance，不存在线程安全问题（由jvm保证线程安全问题），但是存在资源浪费、加载速度慢的问题。
检查代码同上，运行结果同上。
Holder模式
就是利用一个静态内部类来实现instance的实例化。这里利用了静态内部类的一个特性：该内部类的实例与外部类的实例没有绑定关系，而且只有被调用到才会装载，从而实现了延迟加载
publicclassHolderSingleton{
privateObjectdata=newObject();
privateHolderSingleton(){
}
privatestaticclassInnerClass{
privatestaticHolderSingletonsingletoninstance=newHolderSingleton();
}
publicstaticHolderSingletongetInstance(){
returnInnerClass.singletoninstance;
}
publicObjectgetData(){
returndata;
}
publicvoidsetData(Objectdata){
this.data=data;
}
}
测试代码同上，运行结果同上。
在加载InnerClass的时候才会去实例化这个instance，实现了延迟加载，并且同饿汉模式一样，由jvm保证线程安全。这种方法值得推荐。
应用场景:
在整个系统中，只允许共用一个实例的类适合用单例模式来实现，比如:
网站的计数器，只允许存在一个计数器实例；
线程池，只允许存在一个线程池对象；
连接池，只允许存在一个连接池对象；
知识点扩充：
1.为什么要使用单例模式？
在我们日常的工作中，很多对象通常占用非常重要的系统资源，比如：IO处理，数据库操作等，那我们必须要限制这些对象只有且始终使用一个公用的实例，即单例。
2.单例模式的实现方式
构造函数私有化，防止其他类生成唯一公用实例外的实例。且单例类应该被定义为final，也就是说单例类不能被继承，因为如果允许继承那子类就都可以创建实例，违背了类唯一实例的初衷。
类中一个静态变量来保存单实例的引用。
一个共有的静态方法来获取单实例的引用。
3.单例模式的UML类图
4.单例模式的经典实现方式
- 饿汉式：一开始就创建好实例，每次调用直接返回，经典的“拿空间换时间”。
- 懒汉式：延迟加载，第一次调用的时候才加载，然后返回，以后的每次的调用就直接返回。经典“拿时间换空间”,多线程环境下要注意解决线程安全的问题。
- 登记式：对一组单例模式进行的维护，主要是在数量上的扩展，通过线程安全的map把单例存进去，这样在调用时，先判断该单例是否已经创建，是的话直接返回，不是的话创建一个登记到map中，再返回。
以上就是本次毛票票小编结合多篇整理的相关内容，希望能够帮助到大家。
声明：本文内容来源于网络，版权归原作者所有，内容由互联网用户自发贡献自行上传，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任。如果您发现有涉嫌版权的内容，欢迎发送邮件至：czq8825#qq.com（发邮件时，请将#更换为@）进行举报，并提供相关证据，一经查实，本站将立刻删除涉嫌侵权内容。