目录
概述
单例模式(Singleton Pattern)是 Java 中最简单的设计模式之一。这种模式涉及到一个单一的类,该类负责创建自己的对象,同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式,可以直接访问,不需要实例化该类的对象。
特点:
1. 单例类只能有一个实例。
2. 单例类必须自己创建自己的唯一实例。
3. 单例类必须给所有其他对象提供这一实例。
线程不安全单例
饿汉模式
优点:
– 实现简单
– 线程安全
缺点:
– 可能造成资源浪费,即使不使用也会占用内存,特别是实例比较大的时候
适用场景:
只有在初始化类的成本较低或程序总是需要类的实例时才使用
public final class EagerSingleton {
private static EagerSingleton singObj = new EagerSingleton();
private EagerSingleton() {
}
public static EagerSingleton getSingleInstance() {
return singObj;
}
}
懒汉模式
优点:
– 对象仅在需要时被创建,无内存和cpu的浪费
缺点:
– 非线程安全,多个线程同时走到if (null == singObj )
就会创建多个实例
适用场景:
非多线程环境
public final class LazySingleton {
private static LazySingleton singObj = null;
private LazySingleton() {
}
public static LazySingleton getSingleInstance() {
if (null == singObj ) {
singObj = new LazySingleton();
}
return singObj;
}
}
线程安全单例
线程安全单例测试方法,新建多个线程同时实例化单例类,看hashCode是否一致:
class MyThread extends Thread {
@Override
public void run() {
System.out.println(Singleton.getInstance().hashCode());
}
public static void main(String[] args) {
MyThread[] mts = new MyThread[10];
for (int i = 0; i < mts.length; i++) {
mts[i] = new MyThread();
}
for (int j = 0; j < mts.length; j++) {
mts[j].start();
}
}
}
同步方法
优点:
– 对象仅在需要时被创建,无内存和cpu的浪费
– 线程安全,因为给方法加了Synchronized
同步锁
缺点:
– 方法上加锁大幅限制了多线程的效率
适用场景:
不建议使用
public final class ThreadSafeSingleton {
private static ThreadSafeSingleton singObj = null;
private ThreadSafeSingleton() {
}
public static synchronized ThreadSafeSingleton getInstance() {
if (null == singObj) {
singObj = new ThreadSafeSingleton();
}
return singObj;
}
}
同步代码块、双检查
优点:
– 对象仅在需要时被创建,无内存和cpu的浪费
– 线程安全。因为给需要加锁的代码块加了Synchronized
同步锁,且代码块中有双检查
缺点:
– 代码略繁琐
适用场景:
基本上都适用,是一种较优的单例模式实现
class DoubleCheckedSingleton {
private static DoubleCheckedSingleton singObj = null;
private DoubleCheckedSingleton() {
}
public static DoubleCheckedSingleton getInstance() {
if (null == singObj) {
synchronized (DoubleCheckedSingleton.class) {
if (null == singObj) {
singObj = new DoubleCheckedSingleton();
}
}
}
return singObj;
}
}
内部类
优点:
– 对象仅在需要时被创建,无内存和cpu的浪费
– 线程安全
– 代码简洁
缺点:
– 静态内部类虽然保证了单例在多线程并发下的线程安全性,但是在遇到序列化对象时,默认的方式运行得到的结果是多例的。
适用场景:
不涉及序列化与反序列化的场景
public class Singleton {
private static class SingletonHolder {
public final static Singleton instance = new Singleton();
}
public static Singleton getInstance() {
return SingletonHolder.instance;
}
}
静态代码块
优点:
– 静态代码块在使用类的时候被执行一次 ,且仅执行一次,实现了延迟实例化
– 线程安全
缺点:
– 静态内部类虽然保证了单例在多线程并发下的线程安全性,但是在遇到序列化对象时,默认的方式运行得到的结果是多例的。
适用场景:
推荐
public class MySingleton{
private static MySingleton instance = null;
private MySingleton(){}
static{
instance = new MySingleton();
}
public static MySingleton getInstance() {
return instance;
}
}
序列化与反序列化单例问题
在不涉及序列化与反序列化的场景中,以上线程安全的单例类实现都没有问题,但是在反序列化时,默认得到的结果是多例的
单例实现:
public class Singleton {
private static class SingletonHolder {
public final static Singleton instance = new Singleton();
}
public static Singleton getInstance() {
return SingletonHolder.instance;
}
}
测试代码:
public class SingletonTest {
public static void main(String[] args) {
Singleton singleton = Singleton.getInstance();
File file = new File("MySingleton.txt");
try {
FileOutputStream fos = new FileOutputStream(file);
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(singleton);
fos.close();
oos.close();
System.out.println(singleton.hashCode());
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
try {
FileInputStream fis = new FileInputStream(file);
ObjectInputStream ois = new ObjectInputStream(fis);
Singleton rSingleton = (Singleton) ois.readObject();
fis.close();
ois.close();
System.out.println(rSingleton.hashCode());
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
结果:
1023892928
193064360
从结果中我们发现,序列号对象的hashCode和反序列化后得到的对象的hashCode值不一样,说明反序列化后返回的对象是重新实例化的,单例被破坏了。那怎么来解决这一问题呢?
解决办法就是在反序列化的过程中使用readResolve()方法,单例实现的代码如下:
class Singleton implements Serializable {
private static final long serialVersionUID = 1L;
private static class SingletonHolder {
public final static Singleton instance = new Singleton();
}
public static Singleton getInstance() {
return SingletonHolder.instance;
}
protected Object readResolve() throws ObjectStreamException {
System.out.println("调用了readResolve方法!");
return getInstance();
}
}
结果:
1023892928
调用了readResolve方法!
1023892928
对于Serializable和Externalizable类,readResolve方法允许类在将从流中读取的对象返回给调用者之前替换/解析它。通过实现readResolve方法,一个类可以直接控制被反序列化的自身实例的类型和实例。
最新评论