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

一、背景

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

二、基本概念

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

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

2.单例模式的实现方式

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

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

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

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.测试结果

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

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.测试结果

细心的同学已经发现,这种实现方式,在多线程的环境中,是有线程安全安全问题的,有可能两个或多个线程判断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.测试结果

六、改进懒汉式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.测试结果

七、登记式--代码实现

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.测试结果

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

八、总结

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

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

(0)

相关推荐

  • Java双重检查加锁单例模式的详解

    什么是DCL DCL(Double-checked locking)被设计成支持延迟加载,当一个对象直到真正需要时才实例化: class SomeClass { private Resource resource = null; public Resource getResource() { if (resource == null) resource = new Resource(); return resource; } } 为什么需要推迟初始化?可能创建对象是一个昂贵的操作,有时在已知的运

  • Java正确实现一个单例设计模式的示例

    设计模式中的单例,是最常用,也算是比较简单的一个了.我们都知道,要想保证只有一个实例,通常采用加锁和双重检查的方式来实现单例,代码如下. public class SingletonTest { private SingletonTest(){ } private static SingletonTest instance; public static SingletonTest getInstance(){ if(instance == null){ synchronized (Singlet

  • Java的单例设计模式详解

    1.什么是单例模式 生成一个独一无二的,保证任何时刻一个类只有一个实例的模式 确保一个类只有一个实例,并提供一个全局访问点 可以在需要时才创建对象,避免了全局变量在程序启动时就得创建对象的缺点. 2.经典单例模式实现 public class MyInstance{ //第一步:私有化构造器,只有类自身才能调用构造器外部类不能够直接new出这个类的实例对象 private MyInstance(){} //第二步:声明一个全局静态变量来记录自身实例的对象,也是私有的,限制其它外部类访问 priv

  • Java单例模式的讲解

    1,单例模式的要素 1)私有构造方法. 2)public static synchronized的getInstance()方法. 上述2个要素虽然可以保证单例模式的实现,但并不是最好的方式.因为当我们讨论性能时,synchronized方法有着非常昂贵的代价. 2,多线程使用环境下的线程安全实现方式 a)使用double locking机制的懒初始化.代码如下.在这种情况下,当调用getInstance方法时,才会创建单例对象. b)使用静态属性的早初始化.代码如下.下面的实现方式,当类被加载

  • 为何Java单例模式我只推荐两种

    双重检查模式 public class Singleton { private volatile static Singleton singleton; //1:volatile修饰 private Singleton (){} public static Singleton getSingleton() { if (singleton == null) { //2:减少不要同步,优化性能 synchronized (Singleton.class) { // 3:同步,线程安全 if (sin

  • Java多线程实战之单例模式与多线程的实例详解

    1.立即加载/饿汉模式 // 立即加载/饿汉模式 public class MyObject { private static final MyObject myObject = new MyObject(); private MyObject() { } public static MyObject getInstance() { return myObject; } } 立即加载/饿汉模式是在类创建的同时已经创建好一个静态的对象供系统使用,不存在线程安全问题 2.延迟加载/懒汉模式 // 延

  • 9种Java单例模式详解(推荐)

    单例模式的特点 一个类只允许产生一个实例化对象. 单例类构造方法私有化,不允许外部创建对象. 单例类向外提供静态方法,调用方法返回内部创建的实例化对象.  懒汉式(线程不安全) 其主要表现在单例类在外部需要创建实例化对象时再进行实例化,进而达到Lazy Loading 的效果. 通过静态方法 getSingleton() 和private 权限构造方法为创建一个实例化对象提供唯一的途径. 不足:未考虑到多线程的情况下可能会存在多个访问者同时访问,发生构造出多个对象的问题,所以在多线程下不可用这种

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

    一.背景 最近在学习设计模式,在看到单例模式的时候,我一开始以为直接很了解单例模式了,实现起来也很简单,但是实际上单例模式有着好几个变种,并且多线程中涉及到线程安全问题,那么本文我们就来好好聊聊单例模式,说一下经典三种实现方式:饿汉式.懒汉式.登记式.并且解决掉多线程中可能出现的线程安全问题. 二.基本概念 1.为什么要使用单例模式? 在我们日常的工作中,很多对象通常占用非常重要的系统资源,比如:IO处理,数据库操作等,那我们必须要限制这些对象只有且始终使用一个公用的实例,即单例. 2.单例模式

  • java单例模式实现面板切换

    本文实例为大家分享了java单例模式实现面板切换的具体代码,供大家参考,具体内容如下 1.首先介绍一下什么是单例模式: java单例模式是一种常见的设计模式,那么我们先看看懒汉模式: public class Singleton_ { //设为私有方法,防止被外部类引用或实例 private Singleton_(){ System.out.println("懒汉单例模式"); } private static Singleton_ single = null; //并对外只暴露get

  • Java单例模式实现静态内部类方法示例

    Singleton是众多设计模式中最容易理解的一种,也是众多设计模式中较为重要的一种设计模式.接下来我们看看具体介绍. Singleton模式实现的重点在于将构造函数私有化(private),并通过提供静态公有函数(public synchronized static xxx getInstance)来获取定义在类中的静态私有成员(private static xxx instance),通过一个简单的判断静态实例是否为空来控制这个类只能够new一次,即控制了一个类只能有单个实例,一般的实现如下

  • Java单例模式实现的几种方式

    Java单例模式实现的几种方式 单例模式好多书上都是这么写的: public class SingleTon1 { private SingleTon1(){ } private static SingleTon1 instance = null; public static SingleTon1 getInstance(){ if(instance == null){ instance = new SingleTon1(); } return instance; } } 但是实际开发中是不会这

  • java 单例模式(饿汉模式与懒汉模式)

    java 单例模式 饿汉式单例 对于饿汉模式,我们可这样理解:该单例类非常饿,迫切需要吃东西,所以它在类加载的时候就立即创建对象. 懒汉式单例类 对于懒汉模式,我们可以这样理解:该单例类非常懒,只有在自身需要的时候才会行动,从来不知道及早做好准备.它在需要对象的时候,才判断是否已有对象,如果没有就立即创建一个对象,然后返回,如果已有对象就不再创建,立即返回. 单例设计模式常用于JDBC链接数据库 注意: 1 我们常用的是第一种饿汉式,因为: (1)既然采用了单例设计模式,就是为了使用单例类的对象

  • Java 单例模式的实现资料整理

    Java单例模式的实现,对java 单例模式的几种实现方法进行了整理: 单例模式好多书上都是这么写的: public class SingleTon1 { private SingleTon1(){ } private static SingleTon1 instance = null; public static SingleTon1 getInstance(){ if(instance == null){ instance = new SingleTon1(); } return insta

  • Java 单例模式线程安全问题

    Java 单例模式线程安全问题 SpringIOC容器默认提供bean的访问作用域是单例模式.即在整个application生命周期中,只有一个instance.因此在多线程并发下,会有线程安全风险.我们在MVC框架下的servlet就是线程安全的.由于该servlet是在客户端,多并发相对少,但是对于web service端,需要考虑到. ThreadLocal类:为每一个线程提供了一个独立的变量(实例)副本,从各将各个不同的实例访问isolation. 在同步锁机制中,后来者线程等待先行线程

  • java 单例模式(懒汉式与饿汉式)

    java 单例模式 单例模式是一种常用的软件设计模式.在它的可信结构中只包含一个被实例化单例的特殊类.通过单例设计模式可以把整系统中的一个类只有一个实例. 单例设计模式又分为两种方式,懒汉式和饿汉式. (1)懒汉式,就是只有当调用getInstance的时候,才会初始化这个单例. (2)饿汉式,就是一旦加载好类,就把单例初始化完成.即是调用getInstance的时候,单例是已经存在了. 代码如下: 懒汉式单例 /** * Description: * 一.设计了一个懒汉式单例 * * @aut

  • Java单例模式简单示例

    本文实例讲述了Java单例模式.分享给大家供大家参考,具体如下: 在实际开发的时候会有一些需求,在某个类中只能允许同时存在一个对象.这时就需要用到单例模式.代码如下 package org.aaa; public class ex { private static ex e; public static ex getEx() { if (e == null) { e=new ex(); } return e; } private ex() { System.out.println("执行单立模式

  • java 单例模式的实例详解

    java 单例模式的实例详解 概念: java中单例模式是一种常见的设计模式,单例模式分三种:懒汉式单例.饿汉式单例.登记式单例三种. 单例模式有一下特点: 1.单例类只能有一个实例. 2.单例类必须自己自己创建自己的唯一实例. 3.单例类必须给所有其他对象提供这一实例. 单例模式确保某个类只有一个实例,而且自行实例化并向整个系统提供这个实例.在计算机系统中,线程池.缓存.日志对象.对话框.打印机.显卡的驱动程序对象常被设计成单例.这些应用都或多或少具有资源管理器的功能.每台计算机可以有若干个打

随机推荐