单例模式
介绍
对某个类只能存在一个对象实例,并且该类只提供一个取得对象实例的方法(静态方法)。
七种实现方式
- 饿汉式(静态常量)
- 饿汉式(静态代码块)
- 懒汉式(线程不安全)
- 懒汉式(线程安全)
- 双重检查
- 静态内部类
- 枚举
1.饿汉式(静态常量)
步骤:
- 构造器私有化
- 类的内部创建对象
- 向外暴露一个静态的公共方法
代码实现:
class Singleton{
//1.构造器私有化,外部不能new
private Singleton(){
}
//2.本类内部创建对象实例
private final static Singleton single = new Singleton();
//3.提供一个公有的静态方法,返回实例对象
public static Singleton getSingle(){
return single;
}
}
//测试
public class Singleton01 {
public static void main(String[] args) {
Singleton single = Singleton.getSingle();
Singleton single1 = Singleton.getSingle();
System.out.println(single == single1);
}
}
结论:这种单例模式可用,但可能造成内存浪费。
2.饿汉式(静态代码块)
步骤:
- 构造器私有化,外部不能new
- 静态代码块中,创建单例对象
- 提供一个公有的静态方法,返回实例对象
代码实现:
class Singleton{
//1.构造器私有化,外部不能new
private Singleton(){
}
private static Singleton single;
//静态代码块中,创建单例对象
static{
single = new Singleton();
}
//3.提供一个公有的静态方法,返回实例对象
public static Singleton getSingle(){
return single;
}
}
结论:这种单例模式可用,但可能造成内存浪费。
3.懒汉式(线程不安全)
步骤:
- 构造器私有化,外部不能new
- 提供一个静态但公有方法,当使用到该方法时,才去创建对象
代码实现:
class Singleton{
private static Singleton instance;
private Singleton(){}
//提供一个静态但公有方法,当使用到该方法时,才去创建instance
public static Singleton getInstance(){
if (instance == null){
instance =new Singleton();
}
return instance;
}
}
结论:
- 起到懒加载的效果,但只能在单线程下使用。
- 在多线程下,一个线程进入if (instance == null),还没来得及往下执行,另一个线程也通过if语句,会产生多个实例。
- 实际开发中,不建议使用。
4.懒汉式(线程安全,同步方法)
步骤:
- 提供一个静态的公有方法,加入同步处理的代码,解决线程安全问题
代码实现:
class Singleton{
private static Singleton instance;
private Singleton(){}
//提供一个静态的公有方法,加入同步处理的代码,解决线程安全问题
public static synchronized Singleton getInstance(){
if (instance == null){
instance =new Singleton();
}
return instance;
}
}
结论:
- 解决线程不安全
- 效率太低,方法进行同步效率太低
- 实际开发中,不建议使用。
5.双重检查
步骤:
提供一个静态的公有方法,加入双重检查代码.
代码实现:
class Singleton{
private static volatile Singleton instance;
private Singleton(){}
//提供一个静态的公有方法,加入双重检查代码,解决线程安全问题和懒加载问题
public static Singleton getInstance(){
if (instance == null){
synchronized (Singleton.class){
if (instance == null){
instance =new Singleton();
}
}
}
return instance;
}
}
结论:
- 进行两次的if (instance == null)检查,保证线程安全。
- 线程安全;延迟加载;效率较高
- 实际开发中,推荐使用。
6.静态内部类
步骤:
- 构造器私有化
- 写一个静态内部类,类中创建静态属性Singleton对象
- 提供一个静态的公有方法,直接返回SingletonInstance.INSTANCE
代码实现:
class Singleton{
private static volatile Singleton instance;
private Singleton(){}
//写一个静态内部类,类中创建静态属性Singleton对象
private static class SingletonInstance{
private static final Singleton INSTANCE = new Singleton();
}
//提供一个静态的公有方法,直接返回SingletonInstance.INSTANCE
public static synchronized Singleton getInstance(){
return SingletonInstance.INSTANCE;
}
}
结论:
- 采用JVM类装载的机制来保证初始化实例时只有一个线程
- Singleton类被类装载时不会实例化静态内部类,在需要实例化时,调用getInstance()方法,装载SingletonInstance类,来完成Singleton的实例化。
- 避免了线程不安全,利用静态内部类特点实现延迟加载,效率高
- 推荐使用
7.枚举
步骤:
借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题,而且还能防止反序列化重新创建 新的对象。
enum Singleton{
INSTANCE;
public void method(){
System.out.println("单例模式,枚举");
}
}
结论: 推荐使用
8.JDK中的单例模式应用
java.lang.Runtime就是经典的单例模式(饿汉式)
单例模式总结
- 单例模式保证了系统内存中该类只存在一个对象,节省了系统资源,对于一些需要频繁创建销毁的对象,使 用单例模式可以提高系统性能
- 当想实例化一个单例类的时候,必须要记住使用相应的获取对象的方法,而不是使用new
- 单例模式使用的场景:需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多(即:重量级对象),但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象(比如数据源、session 工厂等)