所谓类的单例设计模式,就是采取一定的方法保证在整个的软件系统中,对某个类只能存在一个对象实例 ,并且该类只提供一个取得其对象实例的方法。
单例模式共有8种方式:
- 饿汉式(静态常量),
可以使用
- 饿汉式(静态代码块),
可以使用
- 懒汉式(线程不安全),
不推荐使用
- 懒汉式(同步方法),线程安全,
可以使用,但是不推荐
- 懒汉时(同步代码块),想解决线程安全问题,但是这是一种错误的方法,没有解决线程安全问题。
不能使用
- 双重检查,
推荐使用
- 静态内部类,
推荐使用
- 枚举,
推荐使用
1 饿汉式
饿汉式,类很饿,饥不择食,一上来就会创建对象实例。饿汉式不存在线程安全问题。
1.1 静态常量
步骤:
- 构造器私有化
- 类的内部创建对象
- 向外暴露一个静态的公共方法
getInstance
。
代码实现:
java
public class User {
// 静态常量
private static final User user = new User();
// 私有化构造器,方式外部通过new来创建对象
private User(){
}
// 对外暴露的方法
public static User getInstance() {
return user;
}
}
优点:
- 写法简单,在类装载的时候就完成了实例化,避免了线程同步问题。
缺点:
- 在类装载时就完成类实例化,没有达到懒加载(Lazy Loading)的效果。如果从未使用过这个实例,则会造成内存的浪费。
总结:这种单例模式可用,但是可能造成内存浪费。
1.2 静态代码块
java
public class Book {
private static Book book;
// 静态代码块
static {
book = new Book();
}
// 私有化构造方法,防止外部通过new的方式创建对象
private Book() {}
// 对外暴露获取实例的方法
public static Book getInstance() {
return book;
}
}
该方法和静态常量方法类似。优点缺点与静态常量方法相同。
2 懒汉时
2.1 线程不安全
java
public class Dog {
private static Dog dog;
// 私有化构造方法,防止外部通过new的方式创建对象
private Dog() {}
// 对外暴露获取实例的方法,当调用该方式时,才会创建实例对象
public static Dog getInstance() {
if (dog==null){
dog = new Dog();
}
return dog;
}
}
优点:
- 起到了懒加载的效果,但是只能在单线程下使用。
缺点:
- 如果在多线程下,一个线程进行了
if(dog==null)
判断语句块,还未来得及往下执行,另一个线程也通过了这个判断语句,这时便会产生多个实例,所以在多线程环境下不可使用这种方式。总结:在实际开发中,不要使用这种方式!
2.2 同步方法-线程安全
java
public class Cat {
private static Cat cat;
// 私有化构造方法,防止外部通过new的方式创建对象
private Cat() {}
// 对外暴露获取实例的方法,当调用该方式时,才会创建实例对象。使用synchronized关键字保障线程安全
public static synchronized Cat getInstance(){
if(cat == null){
cat = new Cat();
}
return cat;
}
}
优点:
- 解决了线程不安全问题。
缺点:
- 效率太低了,每个线程在想获得类的实例的时候,执行
getInstance()
方法都要进行同步。而其实这个方法只执行一次实例化代码就够了,后面想获得该类实例,直接return就行了。方法进行同步效率太低。结论:在实际开发中,不推荐使用这种方式!
2.3 同步代码块-不能解决线程安全
在实际开发中,有人尝试解决线程安全问题,但是又想解决同步方法带来的效率低的问题,所以使用了下面的方法。将cat = new Cat()
创建新实例的代码放入了一个同步代码块中。
但是这种方法其实并没有解决线程安全问题。因为可能会多个线程通过if(cat == null)
判断,也会造成多次创建实例的情况。
java
public class Cat {
private static Cat cat;
// 私有化构造方法,防止外部通过new的方式创建对象
private Cat() {}
// 对外暴露获取实例的方法,当调用该方式时,才会创建实例对象。
public static Cat getInstance(){
if(cat == null){
// 同步代码块
synchronized (Cat.class){
cat = new Cat();
}
}
return cat;
}
}
这是一种错误写法!!
2.4 双重检查
volatile
关键字可以让修改值立即更新到主存。在对象的构造过程中,volatile
可以确保在对象引用被赋值给其他线程之前,对象的构造过程已经完成。
如果不加volatile
关键字,一个线程修改了 pig
的值,其他线程可能看不到这个修改,导致可能创建多个实例。
java
public class Pig {
private static volatile Pig pig;
// 私有化构造方法,防止外部通过new的方式创建对象
private Pig() {}
// 对外暴露获取实例的方法,当调用该方式时,才会创建实例对象。
public static Pig getInstance() {
if (pig == null) {
synchronized (Pig.class) {
// 再次检查
if (pig == null) {
pig = new Pig();
}
}
}
return pig;
}
}
双重检查这种方式,在保证线程安全的同时,也具有较高的效率。在实际开发中,推荐使用这种方法。
2.5 静态内部类
当Tigger
类进行装载时,TiggerInstance
静态内部类是不会被装载的。
当我们调用getInstance
方法时,会装载TiggerInstance
内部类,同时静态内部类的静态常量INSTANCE
对象会被创建。
java
public class Tigger {
// 私有化构造方法,防止外部通过new的方式创建对象
private Tigger(){}
// 静态内部类
private static class TiggerInstance {
private static final Tigger INSTANCE = new Tigger();
}
// 对外暴露获取实例的方法,当调用该方式时,才会创建实例对象。
private static Tigger getInstance(){
return TiggerInstance.INSTANCE;
}
}
这种方式采用类加载的机制来保证初始化实例时只有一个线程。
这种方法保证了线程安全,效率高。推荐使用!
2.6 枚举
java
public enum Fish {
INSTANCE;
public void sayOK(){
System.out.println("ok");
}
}
借助枚举实现单利模式,可以避免多线程同步问题,而且还能防止反序列化重新创建新的对象。推荐使用。
3 单例模式注意事项
单例模式保证了系统内存中该类只存在一个对象,节省了系统资源,对于一些需要频繁创建销毁的对象,使用单例模式可以提高系统性能。
当想实例化一个单例类的时候,必须要使用相应的获取对象的方法,而不是直接用new
。
单例模式使用的场景:
- 需要频繁的进行创建和销毁的对象
- 创建对象时耗时过多或耗费资源过多(即重量级对象),但又经常用到的对象
- 工具类对象
- 频繁访问数据库或文件的对象,比如数据源、session工厂等