23种设计模式入门 -- 单例模式
单例模式:采用一定的方法,使得软件运行中,对于某个类只能存在一个实例对象,并且该类只能提供一个取得实例的方法。
分类:
- 饿汉式
- 静态常量方式
- 静态代码块方式
- 懒汉式
- 普通方式,线程不安全
- 同步方法方式,线程安全
- 同步代码块方式,线程不安全
- 其他方式
- 双重检查
- 静态内部类
- 枚举
实现思路:
-
想要实现单例,即不能让外部随意的去实例化对象。所以需要构造器私有
-
既然不允许外部去创建了,所以需要在类的内部创建对象
-
外部需要使用对象,所以需要对外提供一个获取实例的方法
一、饿汉式
根据对象创建的时机,可以分为饿汉式和懒汉式。饿汉式,即在类加载的时候立即创建实例,根据所学知识我们可以很快想到要使用static
关键字将属性和类相关联。以下提供两种书写方式供参考。
特点
- 优点:写法简单,在类装载的时候就完成实例化,避免了线程同步问题
- 缺点:在类装载的时候就完成了实例化,如果开始至终都没有使用这个实例,会造成内存浪费
1.静态常量方式
class Singleton01{
//构造器私有,防止外部new
private Singleton01(){
}
//内部创建对象
private final static Singleton01 instance = new Singleton01();
//提供给外部创建实例的静态方法
public static Singleton01 getInstance(){
return instance;
}
}
2.静态代码块方式
class Singleton02{
//构造器私有,防止外部new
private Singleton02(){
}
//内部创建对象
private static Singleton02 instance;
static {
instance = new Singleton02();
}
//提供给外部创建实例的静态方法
public static Singleton02 getInstance(){
return instance;
}
}
这种方式和静态常量的实现方式逻辑和优缺点是一样的,只是写法不同。
二、懒汉式
懒汉式,即在类加载时并不实例化对象,等到使用对象实例的时候才去实例化,也被称为懒加载效果。这样做的好处可以节约资源,减少浪费,只有需要的时候采取创建,不需要就不会实例化。
1.普通方式(线程不安全)
class Singleton01{
// 构造器私有
private Singleton01(){
}
// 定义静态变量,实例化留在获取实例的getInstance方法,起到懒加载效果
private static Singleton01 instance;
public static Singleton01 getInstance(){
// 判断如果为空才创建,起到懒加载
if (instance == null){
instance = new Singleton01();
}
return instance;
}
}
问题:在多线程情况下,假设类还未第一次实例化,此时两个进程同时执行到了if(instance==null)
,而未来得及往下执行时,此时两者校验都成立,都会执行实例化操作,将有可能出现创建多个实例的问题。
2.同步方法方式(线程安全)
既然存在线程安全问题,肯定会想到使用synchronized
关键字来解决
class Singleton02{
private static Singleton02 instance;
private Singleton02(){
}
//使用synchronized关键字来实现线程安全
public static synchronized Singleton02 getInstance(){
if (instance == null){
instance = new Singleton02();
}
return instance;
}
}
这样的方式可以起到线程安全的效果,但是每个线程都需要等待锁,所以又会存在效率低的问题,于是有人想到了将锁的范围缩小到方法的内部,使用同步代码块的方式
3.同步代码块方式(线程不安全)
这样的方式好不好呢?先看代码
class Singleton03{
private static Singleton03 instance;
private Singleton03(){
}
public static Singleton03 getInstance(){
if (instance == null){
// 这里的synchronized其实没有实际意义,可能会产生多个实例
synchronized (Singleton03.class){
instance = new Singleton03();
}
}
return instance;
}
}
这样锁的范围是变小了,但是还会存在多个线程同时判断到if (instance == null)
,即使在后面加上锁,依旧会在后续创建实例,只是延迟了一点而已,所以这种写法不可取
三、其他方式
1.双重检查
为了能够实现懒加载的效果,同时兼顾效率,于是出现了这种写法
class Singleton01{
//volatile,当有发生变化时即时储存到内存中。防止指令重排
private static volatile Singleton01 instance;
private Singleton01(){
}
//双重检查,解决线程同步问题,又保证效率
public static Singleton01 getInstance(){
if (instance == null){ // 第一次检查,降低产生锁的概率
synchronized (Singleton01.class){
if(instance == null){ // 第二次检查,保证线程安全
instance = new Singleton01();
}
}
}
return instance;
}
}
使用双重检查,第一次检查提升效率,第二次检查保证线程安全,简直美滋滋
2.静态内部类
利用静态内部类在被调用时才会加载,即存在懒加载效果,所以也可以这样写
class Singleton02{
private Singleton02(){
}
/*
静态内部类在外部类装载的时候不会马上执行,起到懒加载作用。
类的静态属性只有在第一次使用的时候才会加载,JVM在类加载时是线程安全的
*/
private static class SingletonInstance{
private static final Singleton02 INSTANCE = new Singleton02();
}
public static Singleton02 getInstance(){
return SingletonInstance.INSTANCE;
}
}
3.枚举
枚举方式是最简单的写法,也是被很多人推崇的写法
enum Singleton03{
INSTANCE;
}
简单明了...
四、小结
使用单例模式,可以使一个类只存在一个实例对象,从而节省了系统资源。
上文中列出了8个写法,其中懒加载的写法存在线程安全和效率的问题,需要谨慎使用。比较推荐的写法有5种:懒加载2种+其他方式3种。当认定单例的对象在软件中一定会用到,可以使用懒加载,反之可以使用其他方式