Java单例模式
设计模式是开发中很重要,单例模式是常用的设计模式。
本文用示例介绍Java的单例模式的写法。有如下六种写法:懒汉式,饿汉式,静态内部类,双重校验锁,枚举,非synchronized的加锁。
简介
单例模式需要考虑如下几点
-
线程安全性
-
懒加载
-
性能
要保证多线程环境下也是单例的,使用的时候才会创建对象,而不是一开始就创建对象,有的实现方式需要每次加锁,这样性能很差,有的实现方式不需要每次都加锁,性能很高。?
本文所述的单例模式都是线程安全的。线程不安全的单例模式,不是合格的单例模式。在下边的单例模式中,我比较喜欢静态内部类。如果涉及到反序列化创建对象我会使用枚举的方式。我永远不会使用饿汉式,如果有其他特殊的需求,我可能会使用双重校验锁。
懒汉
懒汉模式就是,它很懒,直到用到的时候才会去创建对象,而不是一开始就创建对象。
-
支持多线程
-
支持懒加载
-
性能很低(因为是加锁同步)
public class Singleton {
private static Singleton instance;
private Singleton() {
}
public static synchronized Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
饿汉
饿汉模式就是,它很饿,想快点创建对象,此模式在类加载时就立即创建对象。
-
支持多线程(这种方式基于classloder机制保证初始化instance时只有一个线程)
-
不完全支持懒加载(instance在类装载时就实例化,大多数都是调用getInstance方法。但是也不能确定有其他的方式(或者其他的静态方法)导致类装载,这时候初始化instance显然没有达到lazy loading的效果)
-
性能很高(因为使用时不需要加锁同步)
写法一
public class Singleton {
private static Singleton instance = new Singleton();
private Singleton() {
}
public static Singleton getInstance() {
return instance;
}
}
写法二
表面上看起来差别挺大,其实跟法1差不多,都是在类初始化即实例化instance。
public class Singleton {
private static Singleton instance = null;
static {
instance = new Singleton();
}
private Singleton() {
}
public static Singleton getInstance() {
return instance;
}
}
静态内部类
在类内部有一个静态内部类,它持有外部类的实例。
-
支持多线程(同样基于classloder机制保证初始化instance时只有一个线程)
-
支持懒加载
-
Singleton类被装载了,instance不一定被初始化。因为SingletonHolder类没有被主动使用,只有显示通过调用getInstance方法时,才会显式装载SingletonHolder类,从而实例化instance)
-
它跟懒汉式不同的是(很细微的差别):懒汉式是只要Singleton类被装载了,那么instance就会被实例化(没有达到lazy loading效果)
-
一方面:如果实例化instance很耗资源,我想让他延迟加载;另一方面,我不希望在Singleton类加载时就实例化,因为我不能确保Singleton类还可能在其他的地方被主动使用从而被加载,那么这时实例化instance是不合适的。这时,这种方式相比第二种方式(饿汉)就更合理。
-
性能很高(因为使用时不需要加锁同步)
public class Singleton {
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton();
}
private Singleton() {
}
public static Singleton getInstance() {
return SingletonHolder.INSTANCE;
}
}
双重校验锁
此模式用了两次if判断。
- 是懒汉模式的升级版
- 在JDK1.5之后,双重检查锁定才能够正常达到单例效果
- Java 5 以前的 JMM (Java 内存模型)存在缺陷,即使将变量声明成 volatile 也不能完全避免重排序
public class Singleton {
private static volatile Singleton singleton;
private Singleton() {
}
public static Singleton getSingleton() {
if (singleton == null) {
synchronized (Singleton.class) {
if (singleton == null) {
singleton = new Singleton();
}
}
}
return singleton;
}
}
为什么加volatile关键字?
volatile作用:保证有序性、可见性。
有序性
Singleton singleton = new Singleton() 这句话可以分为三步:
1. 为 Singleton 分配内存空间(加载、链接);
2. 初始化 singleton;
3. 将 singleton 指向分配的内存空间。
但是由于JVM具有指令重排的特性,执行顺序有可能变成 1-3-2。指令重排在单线程下不会出现问题,但是在多线程下会导致一个线程获得一个未初始化的实例。例如:线程T1执行了1和3,此时T2调用 getInstance() 后发现 singleton 不为空,因此返回 singleton, 但是此时的 singleton 还没有被初始化。所以,使用 volatile 会禁止JVM指令重排,从而保证在多线程下也能正常执行。
可见性
把变量声明为 volatile,就指示 JVM,修改的值立即被更新到主存。
普通的共享变量不能保证可见性,因为普通共享变量被修改之后,什么时候被写入主存是不确定的,当其他线程去读取时,此时内存中可能还是原来的旧值,因此无法保证可见性。
为什么有两次校验?
第一次校验:也就是第一个if(singleton == null)
这个是为了代码提高代码执行效率。由于单例模式只要一次创建实例即可,所以当创建了一个实例之后,再次调用getInstance方法就不必要进入同步代码块,不用竞争锁。直接返回前面创建的实例即可。
第二次校验:也就是第二个if(singleton == null)
这个校验是防止二次创建实例。假如有一种情况,当singleton还未被创建时,线程t1调用getInstance方法,由于第一次判断singleton ==null,此时线程t1准备继续执行,但是由于资源被线程t2抢占了,此时t2页调用getInstance方法,同样的,由于singleton并没有实例化,t2同样可以通过第一个if,然后继续往下执行,同步代码块,第二个if也通过,然后t2线程创建了一个实例singleton。此时t2线程完成任务,资源又回到t1线程,t1此时也进入同步代码块,如果没有这个第二个if,那么,t1就也会创建一个singleton实例,那么,就会出现创建多个实例的情况,但是加上第二个if,就可以完全避免这个多线程导致多次创建实例的问题。
所以说:两次校验都必不可少。
枚举
Effective Java作者Josh Bloch 提倡的方式。
-
支持多线程(可保证只有一个实例。这与枚举类的实现有关)
-
支持防止反序列化和防止反射破坏单例
public enum Singleton {
INSTANCE;
}
package org.example.a;
enum MyEnum{
FIRST("第一个"),
SECOND("第二个");
private String desc;
private MyEnum(String desc) {
this.desc = desc;
}
public String getDesc() {
return desc;
}
private String lastName;
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
}
public class Demo {
public static void main(String[] args) {
MyEnum.FIRST.setLastName("Tony");
System.out.println(MyEnum.FIRST.getLastName());
System.out.println(MyEnum.FIRST.getDesc());
MyEnum myEnum = MyEnum.FIRST;
MyEnum myEnum1 = MyEnum.FIRST;
System.out.println(myEnum == myEnum1);
}
}
Tony
第一个
true
非synchronized (不常用)
CAS
package org.example.a;
import java.util.concurrent.atomic.AtomicReference;
public class Singleton {
private static final AtomicReference<Singleton> INSTANCE =
new AtomicReference<Singleton>();
private Singleton() {
}
public static Singleton getInstance() {
for (; ; ) {
Singleton singleton = INSTANCE.get();
if (null != singleton) {
return singleton;
}
singleton = new Singleton();
if (INSTANCE.compareAndSet(null, singleton)) {
return singleton;
}
}
}
}
?ThreadLocal
package org.example.a;
public class Singleton {
private static final ThreadLocal<Singleton> singleton =
new ThreadLocal<Singleton>() {
@Override
protected Singleton initialValue() {
return new Singleton();
}
};
public static Singleton getInstance() {
return singleton.get();
}
private Singleton() {
}
}
?
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。 如若内容造成侵权/违法违规/事实不符,请联系我的编程经验分享网邮箱:veading@qq.com进行投诉反馈,一经查实,立即删除!