单例模式
在程序运行过程中,只有一个类的实例,即所有实例的hashcode相同。
饿汉式
在类加载时,立马将类的实例创建出来,无论是否会用到该类的实例。
public class SingletonHungry {
private static final SingletonHungry INSTANCE = new SingletonHungry();
/**
* 构造方法私有化,禁止外部new对象
*/
private SingletonHungry() {}
/**
* 外部获取Singleton对象只能通过getInstance()方法
* @return 对象实例
*/
public static SingletonHungry getInstance() {
return INSTANCE;
}
}
懒汉式(方法锁)
只有需要用到类的实例时,才会创建实例。
public class SingletonLazy {
private static SingletonLazy INSTANCE;
/**
* 构造方法私有化,禁止外部new对象
*/
private SingletonLazy() {}
/**
* synchronized防止多线程访问时进行多次new
*/
public static synchronized SingletonLazy getInstance() {
if (INSTANCE == null) {
INSTANCE = new SingletonLazy();
}
return INSTANCE;
}
}
懒汉式(类锁-双重检查)
只有需要用到类的实例时,才会创建实例,相比于方法锁,缩小了锁的范围,提高运行效率。
public class SingletonLazyDoubleCheck {
/**
* volatile的作用:
* 1.禁止指令重排,防止将处于类加载的准备过程的对象返回(虽然有了默认值,但是还没有初始化)
* 2.线程间可见
*/
private static volatile SingletonLazyDoubleCheck INSTANCE;
/**
* 构造方法私有化,禁止外部new对象
*/
private SingletonLazyDoubleCheck() {}
public static SingletonLazyDoubleCheck getInstance() {
if (INSTANCE == null) {
synchronized (SingletonLazyDoubleCheck.class) {
if (INSTANCE == null) {
INSTANCE = new SingletonLazyDoubleCheck();
}
}
}
return INSTANCE;
}
}
懒汉式-静态内部类
/**
* 静态内部类,在加载类的时候不会创建实例
* 在第一次获取实例时才会创建实例
* @author IT00ZYQ
* @Date 2021/3/16 15:34
**/
public class SingletonInnerClass {
/**
* 私有化构造方法
*/
private SingletonInnerClass() {}
public static SingletonInnerClass getInstance() {
return Inner.INSTANCE;
}
private static class Inner {
/**
* 在静态内部类中创建实例
*/
private final static SingletonInnerClass INSTANCE = new SingletonInnerClass();
}
}
枚举单例
《Effective Java》中推荐的枚举单例。
/**
* @author IT00ZYQ
* @Date 2021/3/16 15:41
**/
public enum SingletonEnum {
/**
* 枚举单例
*/
INSTANCE;
public void method() {
System.out.println("方法" + this.hashCode());
}
}