单例模式
单例模式(Singleton Pattern)是Java中最简单的设计模式之一。这种类型的设计模式属于创建型模式,它保证一个类仅有一个实例,并提供一个访问它的全局访问点,可以防止一个全局使用的类频繁地创建与销毁。所以当我们想要控制实例数目,节约系统资源的时候就可以使用单例模式。
注意事项:
- 单例类只能有一个实例。
- 单例类必须自己创建自己的唯一实例(构造器私有)。
- 单例类必须给所有其他对象提供这一实例。
饿汉式
饿汉式顾名思义就是很饥饿,不管执行啥任务,都得先吃再说,所以当类加载时就初始化了。它基于classloader机制避免了多线程的同步问题,所以是线程安全的。不过很容易产生垃圾对象,造成空间浪费的问题。
//饿汉式单例
public class Hungry {
//假如我们里面有这些代码,是不是就很浪费空间呢
private byte[] data1 = new byte[1024*1024];
private byte[] data2 = new byte[1024*1024];
private byte[] data3 = new byte[1024*1024];
private byte[] data4 = new byte[1024*1024];
//刚进饭馆就要菜,现成的
private static Hungry instance = new Hungry();
private Hungry(){}
public static Hungry getInstance(){
return instance;
}
}
懒汉式
懒汉式-单线程版本
懒汉式就没有饿汉式那么饿了,只要它想要吃饭了再做菜就可以。那么先来个私人饭店版本(单线程版)。
//懒汉式单例,单线程版本
public class Lazy {
//先做好准备,啥时候想吃再做。
private static Lazy instance = null;
private Lazy(){
System.out.println(Thread.currentThread().getName()+"ok");
}
public static Lazy getInstance(){
//饿了,发现没菜,没事不着急,慢慢做。
if(instance == null){
instance = new Lazy();
}
//做好了,上菜。
return instance;
}
//多线程下是不安全的
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
new Thread(()->{
Lazy.getInstance();
}).start();
}
}
}
运行结果:
分析线程不安全原因:
懒汉式-多线程-低性能版
单线程版本既然是在getInstance()方法里面出现了线程不安全,那么可以怎么解决?直接给getInstance()方法加上锁synchronized就好了,但是加锁会影响效率,懒汉想吃饭了想进饭店进不去,被前面的霸道客人直接锁住了,不管有没有菜都得等着。
//懒汉式单例,多线程版本
public class Lazy {
//先做好准备,啥时候想吃再做。
private static Lazy instance = null;
private Lazy(){
System.out.println(Thread.currentThread().getName()+"ok");
}
//饿了,但是发现饭馆里有人,而且只能一个人进去,只能等待
public static synchronized Lazy getInstance(){
if(instance == null){
instance = new Lazy();
}
return instance;
}
//多线程下是安全的
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
new Thread(()->{
Lazy.getInstance();
}).start();
}
}
}
运行结果:
懒汉式-双重校验锁(重点)
懒汉式-双重校验锁(DCL,即double-checked locking),刚才低性能版是把饭店直接锁住了,所以懒汉也不知道厨房有没有做好菜,那么双重校验锁就是让客人们都可以进入饭店,询问服务员有没有做好菜( if(instance == null) ),服务员如果说做好了(false),直接上菜(return),如果说没有做好(true),前面有人(厨房上锁),则等待,前面没人,则进入厨房,上锁,做菜(初始化)。
//懒汉式-双重校验锁
public class Lazy1 {
private volatile static Lazy1 instance = null;
private Lazy1(){}
private static Lazy1 getInstance(){
if(instance == null){
synchronized (Lazy1.class){
if(instance == null){
instance = new Lazy1();
}
}
}
return instance;
}
}
分析为什么使用volatile(重点)
登记式/静态内部类
使用静态内部类方式能达到双重校验锁一样的功效,并且实现起来更简单。对静态域使用延迟初始化,应使用这种方式而不是双重校验锁方式。
//登记式、静态内部类
public class Holder {
private Holder(){}
public static Holder getInstance(){
return InnerClass.HOLDER;
}
public static class InnerClass{
private static final Holder HOLDER = new Holder();
}
}
反射破坏单例
有人上锁就有人撬,反射也是可以创建对象的,并可以消除权限检验,那么接下来就演示一下用反射破坏双重校验锁。
import java.lang.reflect.Constructor;
//反射破解双重校验锁
public class Lazy2 {
private Lazy2(){}
private volatile static Lazy2 instance = null;
public static Lazy2 getInstance(){
if(instance == null){
synchronized (Lazy2.class){
if(instance == null){
instance = new Lazy2();
}
}
}
return instance;
}
//反射破解
public static void main(String[] args) throws Exception {
//用单例模式创建对象
Lazy2 instance = Lazy2.getInstance();
//通过反射获取构造器
Constructor<Lazy2> declaredConstructor = Lazy2.class.getDeclaredConstructor(null);
//消除构造器权限检验
declaredConstructor.setAccessible(true);
//构造对象
Lazy2 instance1 = declaredConstructor.newInstance();
//通过两个对象的hashCode值来对比是否为同一对象
System.out.println(instance.hashCode());
System.out.println(instance1.hashCode());
}
}
运行结果:
枚举式
在我们用反射创建对象调用newInstance()方法时,打开其源代码观察发现,枚举是不可以被破坏的。
枚举式不仅能避免多线程同步问题,而且还自动支持序列化机制,防止反序列化重新创建新的对象,绝对防止多次实例化。
//枚举式,enum本身也是一个Class类
public enum EnumSingle {
INSTANCE;
public EnumSingle getInstance(){
return INSTANCE;
}
}