手写单例模式

2024-03-17 11:35:10

手写单例模式

介绍：

意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
主要解决：一个全局使用的类频繁地创建与销毁。
何时使用：当您想控制实例数目，节省系统资源的时候。
如何解决：判断系统是否已经有这个单例，如果有则返回，如果没有则创建。
关键代码：构造函数是私有的。
优点：
1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。
2、避免对资源的多重占用（比如写文件操作）。
缺点：
没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。
使用场景：

1、要求生产唯一序列号。
2、WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。
3、创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。

注意事项：getInstance() 方法中需要使用同步锁synchronized (Singleton.class) 防止多线程同时进入造成 instance 被多次实例化。

单例模式的几种实现方式：

1、饿汉式（线程安全）
类加载时就初始化实例，避免了多线程同步问题，天然线程安全。
解释：类加载的方式是按需加载，且只加载一次。因此，在上述单例类被加载时，就会实例化一个对象并交给自己的引用，供系统使用，即在线程访问单例对象之前，其就已经创建好了。线程每次都只能拿到这个唯一的对象。因此，饿汉式单例天生就是线程安全的。

public class Singleton {  
    private static Singleton instance = new Singleton();  
    private Singleton (){}  
    public static Singleton getInstance() {  
    return instance;  
    }  
}

2 . 懒汉式（线程不安全）
实例对象在第一次被调用的时候才真正构建的，而不是程序一启动就会自动构建。所以这种滞后构建的方式就叫做懒加载。这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized，多线程场景下不要使用，因为可能会产生多个对象，不再是单例。

public class Singleton {
    private static Singleton singleton;
    private Singleton() {}
    public static Singleton getInstance() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

懒汉式（线程安全，方法上加同步锁）
和上面懒汉式（线程不安全）实现上唯一不同是：获取实例的getInstance()方法上加了同步锁。保证了多线程场景下的单例。

public class Singleton {
    private static Singleton singleton;
    private Singleton() {}
    public static synchronized Singleton getInstance() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

3、双检锁/双重校验锁（DCL，即 double-checked locking）线程安全，效率高
此种实现中不用每次需要获得锁，减少了获取锁和等待的事件。

public class Singleton {
	private volatile static Singleton singleton;
	private Singleton() {}
	public static Singleton getSingleton() {
		if (singleton == null) {
			synchronized (Singleton.class) {
				if (singleton == null) {
						singleton = new Singleton();
				}
			}
		}
		return singleton;
	}
}

问：为什么要有第二个if？
因为如果没有第二个if的话，在当前A线程获得锁的线程后可能有其他如B线程也在等待进入这个Class锁，A线程获取锁后创建实例，然后释放锁，之后等待池中的B线程获得锁，然后就会产生创建两个对象的错误情况。
问：singleton为什么需要采⽤ volatile 关键字修饰？
singleton采⽤ volatile 关键字修饰也是很有必要的，在上述代码中有下面这一句代码
singleton = new Singleton();
其实是分为三步执⾏的：
1.为 singleton 分配内存空间
2. 初始化 singleton
3. 将 singleton 指向分配的内存地址
但是由于 JVM 具有指令重排的特性，执⾏顺序有可能变成 1->3->2。指令重排在单线程环境下不会出现问题，但是在多线程环境下会导致⼀个线程获得还没有初始化的实例。
（例如，线程A 执⾏了 1 和3，此时线程B调⽤ getSingleton () 后发现 singleton 不为空，因此返回singleton，但此时singleton还未被初始化。）
使⽤ volatile 可以禁⽌ JVM 的指令重排，保证在多线程环境下也能正常运⾏。

4、静态内部类实现单例（线程安全、效率高）

这种方式下 Singleton 类被装载了，instance 不一定被初始化。因为 SingletonHolder 类没有被主动使用，只有通过显式调用 getInstance 方法时，才会显式装载 SingletonHolder 类，从而实例化 instance。注意内部类SingletonHolder要用static修饰且其中的静态变量INSTANCE必须是final的。

即：静态内部类不会随着外部类的加载而加载，只有静态内部类的静态成员被调用时才会进行加载 , 这样既保证了惰性初始化，又由JVM保证了多线程并发访问的正确性。（一个类只会被初始化一次，虚拟机会保证一个类的构造器方法在多线程环境中被正确地加载，同步，如果多个线程同时去初始化一个类，那么只有一个线程去执行这个类的构造方法）

public class Singleton {  
    private static class SingletonHolder {  
    	private static final Singleton INSTANCE = new Singleton();  
    }  
    private Singleton (){}  
    public static final Singleton getInstance() {  
    	return SingletonHolder.INSTANCE;  
    }  
}

参考资料

设计模式解释大全

码农公寓