单例模式(Singleton Pattern)
单例模式(Singleton Pattern)是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。
这种模式涉及到一个单一的类,该类负责创建自己的对象,同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式,可以直接访问,不需要实例化该类的对象。
注意:
- 单例类只能有一个实例。
- 单例类必须自己创建自己的唯一实例。
- 单例类必须给所有其他对象提供这一实例
案例场景
- 数据库的连接池不会反复创建
- spring中一个单例模式bean的生成和使用
- 在我们平常的代码中需要设置全局的的一些属性保存
在我们的日常开发中大致上会出现如上这些场景中使用到单例模式,虽然单例模式并不复杂但是使用面却比较广。
单例的实现
1. 饿汉模式(线程安全)
/**
* @Description 饿汉式,类初始化就创建实例
* @Author wqing
* @Date 2022/7/27 15:39
*/
public class Singleton1 {
private static final Singleton1 INSTANCE = new Singleton1();
private Singleton1() {}
public static Singleton1 getInstance(){
return INSTANCE;
}
}
- 优点:没有加锁,执行效率会提高。
- 缺点:类加载时就初始化,浪费内存。
它基于 classloader
机制避免了多线程的同步问题,不过,instance
在类装载时就实例化,虽然导致类装载的原因有很多种,在单例模式中大多数都是调用 getInstance
方法, 但是也不能确定有其他的方式(或者其他的静态方法)导致类装载,这时候初始化 instance
显然没有达到 lazy loading
的效果。
2. 懒汉模式(线程不安全)
/**
* @Description 懒汉式,线程不安全
* @Author wqing
* @Date 2022/7/27 15:57
*/
public class Singleton2 {
private static Singleton2 INSTANCE = null;
private Singleton2() {
}
public Singleton2 getINSTANCE() {
if (INSTANCE == null) {
INSTANCE = new Singleton2();
}
return INSTANCE;
}
}
这种方式是最基本的实现方式,这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized
,所以严格意义上它并不算单例模式。这种方式 lazy loading
很明显,不要求线程安全,在多线程不能正常工作。
3. 懒汉模式(线程安全)
/**
* @Description 懒汉式,线程安全
* @Author wqing
* @Date 2022/7/27 15:59
*/
public class Singleton3 {
private static Singleton3 INSTANCE = null;
private Singleton3() {
}
public synchronized Singleton3 getINSTANCE() {
if (INSTANCE == null) {
INSTANCE = new Singleton3();
}
return INSTANCE;
}
}
此种模式虽然是安全的,但由于把锁加到方法上后,所有的访问都因需要锁占用导致资源的浪费。如果不是特殊情况下,不建议此种方式实现单例例模式。
4. 双重锁校验(线程安全)
/**
* @Description 双重检测锁
* @Author wqing
* @Date 2022/7/27 16:04
*/
public class Singleton4 {
private static volatile Singleton4 INSTANCE = null; //保证可见性、有序性
private Singleton4() {
}
public Singleton4 getINSTANCE() {
if (INSTANCE == null) {
synchronized (Singleton4.class) {
if (INSTANCE == null) {
INSTANCE = new Singleton4();
}
}
}
return INSTANCE;
}
}
- 双重锁的方式是方法级锁的优化,减少了部分获取实例的耗时。
- 同时这种方式也满足了懒加载。
5. 使用类的内部类(线程安全)
/**
* @Description 饿汉式--内部类
* @Author wqing
* @Date 2022/7/27 16:22
*/
public class Singleton5 {
private Singleton5() {
}
private static class InnerInstance{
static Singleton5 INSTANCE = new Singleton5();
}
public static Singleton5 getInstance() {
return InnerInstance.INSTANCE;
}
}
- 使用类的静态内部类实现的单例模式,既保证了线程安全有保证了懒加载,同时不会因为加锁的方式耗费性能。
- 这主要是因为JVM虚拟机可以保证多线程并发访问的正确性,也就是一个类的构造方法在多线程环境下可以被正确的加载。
- 此种方式也是非常推荐使用的一种单例例模式
6. Effective Java作者推荐的枚举单例(线程安全)
/**
* @Description 枚举实现
* @Author wqing
* @Date 2022/7/27 16:42
*/
public enum Singleton6 {
INSTANCE;
}
这种实现方式还没有被广泛采用,但这是实现单例模式的最佳方法。它更简洁,自动支持序列化机制,绝对防止多次实例化。
这种方式是 Effective Java 作者 Josh Bloch 提倡的方式,它不仅能避免多线程同步问题,而且还自动支持序列化机制,防止反序列化重新创建新的对象,绝对防止多次实例化。不过,由于 JDK1.5 之后才加入 enum 特性,用这种方式写不免让人感觉生疏,在实际工作中,也很少用。
不能通过 reflection attack 来调用私有构造方法。