技术文章
当前位置:首页 > Java技术文章 > 你真的了解java单例模式了吗

java单例模式知识点深入了解

  • 发布时间:
  • 作者:码农之家原创
  • 点击:100

这篇文章主要知识点是关于java、单例模式、全面解析Java设计模式之单例模式 的内容,如果大家想对相关知识点有系统深入的学习,可以参阅以下java相关的电子书

Java遗传算法编程
Java遗传算法编程全目录中文版
  • 类型:Java算法大小:28.8 MB格式:PDF出版:人民邮电出版社作者:雅各布森/坎贝尔
立即下载

更多Java相关的学习资源可以参阅 Java电子书程序设计电子书 等栏目。

你真的了解java单例模式了吗

一、背景

最近在学习设计模式,在看到单例模式的时候,我一开始以为直接很了解单例模式了,实现起来也很简单,但是实际上单例模式有着好几个变种,并且多线程中涉及到线程安全问题,那么本文我们就来好好聊聊单例模式,说一下经典三种实现方式:饿汉式、懒汉式、登记式。并且解决掉多线程中可能出现的线程安全问题。

二、基本概念

1.为什么要使用单例模式?

在我们日常的工作中,很多对象通常占用非常重要的系统资源,比如:IO处理,数据库操作等,那我们必须要限制这些对象只有且始终使用一个公用的实例,即单例。

2.单例模式的实现方式

构造函数私有化,防止其他类生成唯一公用实例外的实例。且单例类应该被定义为final,也就是说单例类不能被继承,因为如果允许继承那子类就都可以创建实例,违背了类唯一实例的初衷。

类中一个静态变量来保存单实例的引用。

一个共有的静态方法来获取单实例的引用。
3.单例模式的UML类图

你真的了解java单例模式了吗?

4.单例模式的经典实现方式

  • 饿汉式:一开始就创建好实例,每次调用直接返回,经典的“拿空间换时间”。
  • 懒汉式:延迟加载,第一次调用的时候才加载,然后返回,以后的每次的调用就直接返回。经典“拿时间换空间”,多线程环境下要注意解决线程安全的问题。
  • 登记式:对一组单例模式进行的维护,主要是在数量上的扩展,通过线程安全的map把单例存进去,这样在调用时,先判断该单例是否已经创建,是的话直接返回,不是的话创建一个登记到map中,再返回。

三、饿汉式---代码实现

1.单例类

package com.hafiz.designPattern.singleton;
/**
* Desc: 单例模式-饿汉式
* Created by hafiz.zhang on 2017/9/26.
*/
public class Singleton1 {
// 创建全局静态变量,保证只有一个实例
private static volatile Singleton1 instance = new Singleton1();
private Singleton1() {
// 构造函数私有化
System.out.println("--调用饿汉式单例模式的构造函数--");
}
public static Singleton1 getInstance() {
System.out.println("--调用饿汉式单例模式的静态方法返回实例--");
return instance;
}
}

2.测试类

public class DesignPatternTest {
@Test
public void testSingleton1() {
System.out.println("-----------------测试饿汉式单例模式开始--------------");
Singleton1 instance1 = Singleton1.getInstance();
System.out.println("第二次获取实例");
Singleton1 instance2 = Singleton1.getInstance();
System.out.println("instance1和instance2是否为同一实例?" + (instance1 == instance2));
System.out.println("-----------------测试饿汉式单例模式结束--------------");
}
}

3.测试结果

你真的了解java单例模式了吗?

四、懒汉式---代码实现

1.单例类

package com.hafiz.designPattern.singleton;
/**
* Desc:单例模式-懒汉式
* Created by hafiz.zhang on 2017/9/26.
*/
public class Singleton2 {
// 创建全局静态变量,保证只有一个实例
private static Singleton2 instance = null;
// 构造函数私有化
private Singleton2() {
System.out.println("--调用懒汉式单例模式的构造方法--");
}
public static Singleton2 getInstance() {
System.out.println("--调用懒汉式单例模式获取实例--");
if (instance == null) {
System.out.println("--懒汉式单例实例未创建,先创建再返回--");
instance = new Singleton2();
}
return instance;
}
}

2.测试类

public class DesignPatternTest {
@Test
public void testSingleton2() {
System.out.println("-----------------测试懒汉式单例模式开始--------------");
Singleton2 instance1 = Singleton2.getInstance();
System.out.println("第二次获取实例");
Singleton2 instance2 = Singleton2.getInstance();
System.out.println("instance1和instance2是否为同一实例?" + (instance1 == instance2));
System.out.println("-----------------测试懒汉式单例模式结束--------------");
}
}

3.测试结果

你真的了解java单例模式了吗?

细心的同学已经发现,这种实现方式,在多线程的环境中,是有线程安全安全问题的,有可能两个或多个线程判断instance都为null,然后创建了好几遍实例,不符合单例的思想,我们可以对它进行改进。

五、改进懒汉式1---代码实现

原理:使用JDK的synchronized同步代码块来解决懒汉式线程安全问题。

1.单例类

package com.hafiz.designPattern.singleton;
/**
* Desc:单例模式-懒汉式
* Created by hafiz.zhang on 2017/9/26.
*/
public class Singleton2 {
// 创建全局静态变量,保证只有一个实例
private static Singleton2 instance = null;
// 构造函数私有化
private Singleton2() {
System.out.println("--调用懒汉式单例模式的构造方法--");
}

public static Singleton2 getInstance() {
System.out.println("--调用懒汉式单例模式获取实例--");
     if (instance != null) {
        System.out.println("--懒汉式单例实例已经创建,直接返回--");
 return instance;
     }
synchronized (Singleton2.class) {
   if (instance == null) {
  System.out.println("--懒汉式单例实例未创建,先创建再返回--");
  instance = new Singleton2();
   }
}
return instance;
}
} 

2.测试结果

你真的了解java单例模式了吗?

六、改进懒汉式2---代码实现

原理:使用JVM隐含的同步和类级内部类来解决,JVM隐含的同步解决了多线程情况下线程安全的问题,类级内部类解决只有使用的时候才加载(延迟加载)的问题。

1.JVM隐含的同步有哪些?

静态初始化器(在静态字段上或static{}静态代码块的初始化器)初始化数据时

访问final字段时

在创建线程之前创建对象时

线程可以看见它将要处理的对象时

2.什么是类级内部类?

有static修饰的成员式内部类。没有static修饰的成员式内部类叫对象级内部类。

类级内部类相当于其外部类的static成分,他的对象与外部类对象间不存在依赖关系,因此可直接创建,而对象级内部类的实例,是绑定在外部对象实例中的。

类级内部类中,可以定义静态的方法。在静态的方法中只能够引用外部类的中的静态成员方法或者成员变量

类级内部类相当于其外部类的成员,只有在第一次被使用的时候才会被装载

3.单例类

package com.hafiz.designPattern.singleton;
/**
* Desc:单例模式-改进懒汉式
* Created by hafiz.zhang on 2017/9/26.
*/
public class Singleton3 {
private static class Singleton4 {
private static Singleton3 instance;
static {
System.out.println("--类级内部类被加载--");
instance = new Singleton3();
}
private Singleton4() {
System.out.println("--调用类级内部类的构造函数--");
}
}
private Singleton3() {
System.out.println("--调用构造函数--");
}
public static Singleton3 getInstance() {
System.out.println("--开始调用共有方法返回实例--");
Singleton3 instance;
System.out.println("---------------------------");
instance = Singleton4.instance;
System.out.println("返回单例");
return instance;
}
}

4.测试类

package com.hafiz.www;
import com.hafiz.designPattern.observer.ConcreteObserver;
import com.hafiz.designPattern.observer.ConcreteSubject;
import com.hafiz.designPattern.singleton.Singleton1;
import com.hafiz.designPattern.singleton.Singleton2;
import com.hafiz.designPattern.singleton.Singleton3;
import com.hafiz.designPattern.singleton.Singleton4;
import com.hafiz.designPattern.singleton.Singleton4Child1;
import com.hafiz.designPattern.singleton.SingletonChild2;
import org.junit.Test;
/**
* Desc:设计模式demo单元测试类
* Created by hafiz.zhang on 2017/7/27.
*/
public class DesignPatternTest {
@Test
public void testSingleton3() {
System.out.println("-----------------测试改进懒汉式单例模式开始--------------");
Singleton3 instance1 = Singleton3.getInstance();
System.out.println("第二次获取实例");
Singleton3 instance2 = Singleton3.getInstance();
System.out.println("instance1和instance2是否为同一实例?" + (instance1 == instance2));
System.out.println("-----------------测试改进懒汉式单例模式结束--------------");
}
}

5.测试结果

你真的了解java单例模式了吗?

七、登记式--代码实现

1.基类

package com.hafiz.designPattern.singleton;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* Desc: 单例模式-登记式
* Created by hafiz.zhang on 2017/9/26.
*/
public class Singleton4 {
private static Map<String, Singleton4> map = new ConcurrentHashMap<>();
protected Singleton4() {
System.out.println("--私有化构造函数被调用--");
}
public static Singleton4 getInstance(String name) {
if (name == null) {
name = Singleton4.class.getName();
System.out.println("--name为空,默认赋值为:--" + Singleton4.class.getName());
}
if (map.get(name) != null) {
System.out.println("name对应的值存在,直接返回");
return map.get(name);
}
System.out.println("name对应的值不存在,先创建,再返回");
try {
Singleton4 result = (Singleton4)Class.forName(name).newInstance();
map.put(name, result);
return result;
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return null;
}
public Map<String, Singleton4> getMap() {
return map;
}
}

2.子类1

package com.hafiz.designPattern.singleton;
/**
* Desc:
* Created by hafiz.zhang on 2017/9/26.
*/
public class Singleton4Child1 extends Singleton4 {

public static Singleton4Child1 getInstance() {
return (Singleton4Child1) Singleton4.getInstance("com.hafiz.designPattern.singleton.Singleton4Child1");
}
}

3.子类2

package com.hafiz.designPattern.singleton;
/**
* Desc:
* Created by hafiz.zhang on 2017/9/26.
*/
public class SingletonChild2 extends Singleton4 {
public static SingletonChild2 getInstance() {
return (SingletonChild2) Singleton4.getInstance("com.hafiz.designPattern.singleton.SingletonChild2");
}
}

4.测试类

public class DesignPatternTest {
@Test
public void testSingleton4() {
System.out.println("-----------------测试登记式单例模式开始--------------");
System.out.println("第一次取得实例");
Singleton4 instance1 = Singleton4.getInstance(null);
System.out.println("res:" + instance1);
System.out.println("第二次获取实例");
Singleton4Child1 instance2 = Singleton4Child1.getInstance();
System.out.println("res:" + instance2);
System.out.println("第三次获取实例");
SingletonChild2 instance3 = SingletonChild2.getInstance();
System.out.println("res:" + instance3);
System.out.println("第四次获取实例");
SingletonChild2 instance4 = new SingletonChild2();
System.out.println("res:" + instance4);
System.out.println("输出父类Map中所有的单例");
Map<String, Singleton4> map = instance1.getMap();
for (Map.Entry<String, Singleton4> item : map.entrySet()) {
System.out.println("map-item:" + item.getKey() + "=" + item.getValue());
}
System.out.println("instance1和instance2是否为同一实例?" + (instance1 == instance2));
System.out.println("-----------------测试登记式单例模式结束--------------");
}
}

5.测试结果

你真的了解java单例模式了吗?

该解决方案的缺点:基类的构造函数对子类公开了(protected),有好的解决方案的博友可以讨论指教~

八、总结

经过本文,我们就搞明白了什么叫单例模式,如何优雅的实现经典的单例模式,如何进行拓展和开发具有线程安全的单例模式。对于我们以后的开发非常有帮助,也让我们更加了解单例模式。

全面解析Java设计模式之单例模式

本文实例为大家分享了Java设计模式之单例模式的具体代码,供大家参考,具体内容如下

概念:

单例模式:一个类中只有一个实例。

一个类有且仅有一个实例,并且提供了一个全局的访问点。

使用该模式的起因:

  当我们在浏览网站时,有些网站会显示“当前在线人数”。通常,实现这个功能的办法是将登陆的每一个IP存储在一个内存、文件或者数据库中,每多一个IP,就实现“+1”。一般就是用一个方法,比如add(),实现“+1”的功能,比如用“update”语句,先获取数据库中存储的数据,再+1,更新数据库中的数据,,然后保存;显示在页面时,再通过另外的方法获取数据库中的数据即可。但是,当多个用户同时登陆时,如果每一个都要new一个对象,然后再通过“对象.方法名”调用执行add()方法,再将数据存储到数据库中,这样就会导致多个用户无法将实际的用户数据准确的记录到数据库中。所以,把这个计数器设计为一个全局对象(所有人都使用这一个对象,而不是用一个,new一个),所有人都共用同一份数据,就可以避免类似的问题,这就是我们所说的单例模式的其中的一种应用。 

同样的,还有其他场景中,也会遇到相似的情景,使用到类似的思路。比如:

   1.外部资源:每台计算机有若干个打印机,但只能有一个PrinterSpooler,以避免两个打印作业同时输出到打印机。内部资源:大多数软件都有一个(或多个)属性文件存放系统配置,这样的系统应该有一个对象管理这些属性文件
   2. Windows的Task Manager(任务管理器)就是很典型的单例模式(这个很熟悉吧),想想看,是不是呢,你能打开两个windows task manager吗? 不信你自己试试看哦~
   3. windows的Recycle Bin(回收站)也是典型的单例应用。在整个系统运行过程中,回收站一直维护着仅有的一个实例。
   4. 网站的计数器,一般也是采用单例模式实现,否则难以同步。
   5. 应用程序的日志应用,一般都何用单例模式实现,这一般是由于共享的日志文件一直处于打开状态,因为只能有一个实例去操作,否则内容不好追加。
   6. Web应用的配置对象的读取,一般也应用单例模式,这个是由于配置文件是共享的资源。
   7. 数据库连接池的设计一般也是采用单例模式,因为数据库连接是一种数据库资源。数据库软件系统中使用数据库连接池,主要是节省打开或者关闭数据库连接所引起的效率损耗,这种效率上的损耗还是非常昂贵的,因为何用单例模式来维护,就可以大大降低这种损耗。
   8. 多线程的线程池的设计一般也是采用单例模式,这是由于线程池要方便对池中的线程进行控制。
   9. 操作系统的文件系统,也是大的单例模式实现的具体例子,一个操作系统只能有一个文件系统。
   10. HttpApplication 也是单位例的典型应用。熟悉ASP.Net(IIS)的整个请求生命周期的人应该知道HttpApplication也是单例模式,所有的HttpModule都共享一个HttpApplication实例。 

总结起来,单例模式的一般应用场景为:

    1.需要频繁实例化然后销毁的对象。

    2.创建对象时耗时过多或者耗资源过多,但又经常用到的对象。

      3.有状态的工具类对象。

    4.频繁访问数据库或者文件的对象。

    5.资源共享的情况下,避免由于资源操作时导致的性能或损耗等。如上述中的日志文件、应用配置等。

    6.控制资源的情况下,方便资源之间的互相通信。如线程池等。

特点:

1、单例类只能有一个实例;

2、单例类必须自己创建自己的唯一实例;

3、单例类必须给所有其他对象提供这一实例

单例模式要素: 

   1.私有构造方法
   2.私有静态引用指向自己实例
   3.以自己实例为返回值的公有静态方法 

实现单例模式的三种方法:

1.饿汉式:单例实例在类装载时就构建,急切初始化。(预先加载法)

/**
* 饿汉式(推荐)
*
*/
public class Test {
    private Test() {
    }
    public static Test instance = new Test();
    public Test getInstance() {
        return instance;
    }
}

优点 

    1.线程安全
    2.在类加载的同时已经创建好一个静态对象,调用时反应速度快

缺点 

    资源效率不高,可能getInstance()永远不会执行到,但执行该类的其他静态方法或者加载了该类(class.forName),那么这个实例仍然初始化

2.懒汉式:单例实例在第一次被使用时构建,延迟初始化。

class Test {
    private Test() {
    }
    public static Test instance = null;
    public static Test getInstance() {
        if (instance == null) {
       //多个线程判断instance都为null时,在执行new操作时多线程会出现重复情况
            instance = new Singleton2();
        }
        return instance;
    }
}

优点 

    避免了饿汉式的那种在没有用到的情况下创建事例,资源利用率高,不执行getInstance()就不会被实例,可以执行该类的其他静态方法。

缺点 

    懒汉式在单个线程中没有问题,但多个线程同事访问的时候就可能同事创建多个实例,而且这多个实例不是同一个对象,虽然后面创建的实例会覆盖先创建的实例,但是还是会存在拿到不同对象的情况。解决这个问题的办法就是加锁synchonized,第一次加载时不够快,多线程使用不必要的同步开销大。

3.双重检测

class Test {
    private Test() {
    }
    public static Test instance = null;

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

优点 

    资源利用率高,不执行getInstance()就不被实例,可以执行该类其他静态方法

缺点 

    第一次加载时反应不快,由于java内存模型一些原因偶尔失败

4.静态内部类

class Test {
    private Test() {
    }

    private static class SingletonHelp {
        static Test instance = new Test();
    }

    public static Test getInstance() {
        return SingletonHelp.instance;
    }
}

优点 

    资源利用率高,不执行getInstance()不被实例,可以执行该类其他静态方法

缺点 

    第一次加载时反应不够快

总结: 

    一般采用饿汉式,若对资源十分在意可以采用静态内部类,不建议采用懒汉式及双重检测

 以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持码农之家。

以上就是本次给大家分享的关于Java的全部知识点内容总结,大家还可以在下方相关文章里找到Java IO流之字符缓冲流的实、 swing组件JScrollPane滚动条实、 WebUploader实现分片断点上传、 等java文章进一步学习,感谢大家的阅读和支持。

上一篇:快速创建spring boot项目的完整步骤

下一篇:Java StringBuffer类与StringBuilder类的实例用法

展开 +

收起 -

相关电子书
学习笔记
网友NO.604134

详解Java设计模式之单例模式

一、场景描述 在采集到仪器数据后,需要将数据发送到lims系统中,通过调用lims系统服务实现数据的上传。 在仪器数据采集组件中实现lims系统服务代理,该代理需要指定服务地址url,认证信息(用户名、密码)。 因此创建该代理需要耗费一些资源,另外该代理并不需要创建多个实例,此种情况下就可以使用单例模式,使得仅创建一个服务代理类实例。 二、实现示例 package lims.designpatterndemo.singletondemo;public class LimsService { private static String url; private static String username; private static String password; // private static LimsService service = null; //私有构造函数 private LimsService(){ url = "http://serviceurl"; username = "admin"; password = "pswd"; } public static LimsService getService(){ if(service==null){ service = new LimsService(); } return service; } // public boolean uploadEquipmentData(String equipmentData){ return true; }} 调用示……

网友NO.323593

JavaScript实现单例模式实例分享

传统单例模式 保证一个类仅有一个实例,并提供一个访问它的全局访问点。 实现单例核心思想 无非是用一个变量来标志当前是否已经为某个类创建过对象,如果是,则在下一次获取该类的实例时,直接返回之前创建的对象,接下来我们用JavaScript来强行实现这个思路,请看代码: var Singleton = function( name ){ this.name = name;};Singleton.prototype.getName = function(){ alert ( this.name );};Singleton.getInstance = (function(){ var instance = null; return function( name ){ if ( !instance ){ instance = new Singleton( name ); } return instance; }})(); 我们通过Singleton.getInstance来获取Singleton类的唯一对象,这样确实是没问题的,但是js本身是没有类这种概念的,所以我们强行用传统单例思想来实现是没有任何意义的,这样的代码又臭又长(其实是我自己看着不舒服嘻嘻嘻)。下面我们使用JavaScript的闭包来实现一个单……

网友NO.428427

JavaScript设计模式之单例模式原理与用法实例分析

本文实例讲述了JavaScript设计模式之单例模式原理与用法。分享给大家供大家参考,具体如下: 单例模式的定义: 保证一个类仅有一个实例,并提供一个访问它的全局访问点。 单例模式是一种常用的模式,有些对象只需要一个,如线程池、全局缓存、浏览器中的window对象等,这时候可以用到单例模式。 单例模式典型的应用场景:单击按钮时,页面中会出现一个登陆浮窗,而该登录浮窗是唯一的,无论单击多少次按钮,这个浮窗都会被创建一次,则适合用单例模式创建。 全局变量不是单例模式,但在JavaScript开发中,经常会把全局变量当成单例来使用。 使用 var a = {}; 这种方式创建对象a时,对象a是独一无二的,若变量a被声明在全局作用域下,则可以在代码的任何位置使用这个变量。这显然满足单例模式的两个条件。 但是全局变量存在很多问题,很容……

网友NO.224066

全面解析Java设计模式之单例模式

本文实例为大家分享了Java设计模式之单例模式的具体代码,供大家参考,具体内容如下 概念: 单例模式:一个类中只有一个实例。 一个类有且仅有一个实例,并且提供了一个全局的访问点。 使用该模式的起因: 当我们在浏览网站时,有些网站会显示“当前在线人数”。通常,实现这个功能的办法是将登陆的每一个IP存储在一个内存、文件或者数据库中,每多一个IP,就实现“+1”。一般就是用一个方法,比如add(),实现“+1”的功能,比如用“update”语句,先获取数据库中存储的数据,再+1,更新数据库中的数据,,然后保存;显示在页面时,再通过另外的方法获取数据库中的数据即可。但是,当多个用户同时登陆时,如果每一个都要new一个对象,然后再通过“对象.方法名”调用执行add()方法,再将数据存储到数据库中,这样就会导致多个用户无法将……

<
1
>

Copyright 2018-2020 xz577.com 码农之家

电子书资源由网友、会员提供上传,本站记录提供者的基本信息及资源来路

鸣谢: “ 码小辫 ” 公众号提供回调API服务、“ 脚本CDN ”提供网站加速(本站寻求更多赞助支持)

版权投诉 / 书籍推广 / 赞助:520161757@qq.com

上传资源(网友、会员均可提供)

查看最新会员资料及资源信息