单例设计模式：采取某种方法，对某个类在整个系统中，只有一个对象实例。比如Hibernate 的SessionFactory，一个数据源只需要一个SessionFactory就够了。
适用于频繁创建和销毁的对象，工具类对象，频繁使用数据库或文件的对象(比如数据源，session工厂等)
单例模式 可以细分为以下几种
- 饿汉式(静态常量)
- 饿汉式(静态代码块)
- 懒汉式(线程不安全)
- 懒汉式(同步方法，线程安全)
- 懒汉式(同步代码块，线程不安全)
- 双锁检验
- 静态内部类
- 枚举
饿汉式(静态常量)
public class SingletonTest01 {
public static void main(String[] args) {
//测试
Singleton instance = Singleton.getInstance();
Singleton instance2 = Singleton.getInstance();
System.out.println(instance == instance2); // true
System.out.println("instance.hashCode=" + instance.hashCode());
System.out.println("instance2.hashCode=" + instance2.hashCode());
}
}
//饿汉式(静态变量)
class Singleton {
//1. 构造器私有化, 防止外部new
private Singleton() {}
//2.本类内部创建静态对象实例
private final static Singleton instance = new Singleton();
//3. 提供一个公有的静态方法，返回实例对象
public static Singleton getInstance() {
return instance;
}
}
分析:
这种写法非常简单，没有线程问题，利用类装载的时候创建对象，但是导致类装载的时机是很多的，因此资源浪费的问题。
资源浪费不是特别严重的问题，因此总体是可以接受的，是可用的。
饿汉式(静态代码块)
class Singleton {
private Singleton() {}//构造方法私有化，防止外部new
//2.本类内部创建对象实例
private static Singleton instance;
static { // 在静态代码块中，创建单例对象
instance = new Singleton();
}
//3. 提供一个公有的静态方法，返回实例对象
public static Singleton getInstance() {
return instance;
}
}
这种方法和上面的几乎一样，只不过将对象实例化的过程放到了代码块中。优缺点和上面的是一样的。
懒汉式(线程不安全)
class Singleton {
private static Singleton instance;
private Singleton() {}
//提供一个静态的公有方法，当使用到该方法时，才去创建 instance
public static Singleton getInstance() {
if(instance == null) {
instance = new Singleton();
}
return instance;
}
}
起到了懒加载的效果，但是在多线程环境下不安全，可能会创建多个对象实例出来，因此这个方法是不能使用的
懒汉式(同步方法，线程安全)
// 懒汉式(线程安全，同步方法)
class Singleton {
private static Singleton instance;
private Singleton() {}
//提供一个静态的公有方法，加入同步处理的代码，解决线程安全问题
public static synchronized Singleton getInstance() {
if(instance == null) {
instance = new Singleton();
}
return instance;
}
}
解决了线程安全的问题，但是效率比较低，如果系统中要频繁的获取对象实例，那么这种方法毫无疑问是不推荐的。
懒汉式(同步代码块，线程不安全)
class Singleton {
private static Singleton instance;
private Singleton() {}
//提供一个静态的公有方法，加入同步处理的代码，解决线程安全问题
public static Singleton getInstance() {
if(instance == null) {
synchronized (Singleton.class){
instance = new Singleton();
}
}
return instance;
}
}
毫无疑问 这是线程不安全的，多线程环境下不能使用这个方法。
双锁检验
class Singleton {
private static volatile Singleton instance;//volatile 抑制指令重排序
private Singleton() {}
//提供一个静态的公有方法，加入双重检查代码，解决线程安全问题, 同时解决懒加载问题
//同时保证了效率, 推荐使用
public static Singleton getInstance() {
if(instance == null) {
synchronized (Singleton.class) {
if(instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
线程安全，实现了懒加载，实际中可以使用这种方式。
静态内部类
class Singleton {
private Singleton() {}//构造器私有化
//写一个静态内部类,该类中有一个静态属性 Singleton
private static class SingletonInstance {
private static final Singleton INSTANCE = new Singleton();
}
//提供一个静态的公有方法，直接返回SingletonInstance.INSTANCE
public static synchronized Singleton getInstance() {
return SingletonInstance.INSTANCE;
}
}
在加载外部类Singleton 时候，内部类SingletonInstance 不会被加载，只是在调用外部类的getInstance()方法时，内部类SingletonInstance才会去加载，这种方法线程安全，实现了延迟加载，并且代码简单，推荐使用这种方法
枚举
public class SingletonTest08 {
public static void main(String[] args) {
Singleton instance = Singleton.INSTANCE;
Singleton instance2 = Singleton.INSTANCE;
System.out.println(instance == instance2);
System.out.println(instance.hashCode());
System.out.println(instance2.hashCode());
instance.sayOK();
}
}
//使用枚举，可以实现单例, 推荐
enum Singleton {
INSTANCE; //属性
public void sayOK() {
System.out.println("ok~");
}
}
线程安全，还能防止反序列化重新创建新的对象，这种方法是Effective Java的作者Josh BLoch提倡的方法。 推荐使用这种方法。
JDK中使用的设计模式
JDK中的java.lang.Runtime 类中就用的了饿汉式实现单例模式
网友评论