你真的了解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),有好的解决方案的博友可以讨论指教~

八、总结

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

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