定义:保证一个类只有一个实例,并且提供一个全局访问点(并且该类只提供一个取得其对象实例的方法(静态方法))。
场景:线程池、数据库连接池。
可以防止反复创建重量级类,节省内存。
实现方式 懒汉模式使用的时候才开始实例化
- 方式一:静态方法,线程不安全
import java.util.concurrent.TimeUnit;
public class SingletonTest {
public static void main(String[] args){
new Thread(()->{
LazySingleton lazySingleton = null;
lazySingleton = LazySingleton.getInstance();
System.out.println(lazySingleton);
},"t1").start();
new Thread(()->{
LazySingleton lazySingleton = null;
lazySingleton = LazySingleton.getInstance();
System.out.println(lazySingleton);
},"t1").start();
LazySingleton lazySingleton = LazySingleton.getInstance();
}
}
class LazySingleton{
private static LazySingleton instance;
public static LazySingleton getInstance() {
if (instance == null){
// 停留2秒,这样会有多个线程进到这里,即实例了n次,那就不是单例模式了
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
instance = new LazySingleton();
}
return instance;
}
private LazySingleton(){
}
}
com.wzq.basics.singleton.LazySingleton@341867b0
com.wzq.basics.singleton.LazySingleton@1ce768be
结果是2个实例的,线程都进入了if (instance == null),会new多个实例,线程不安全,如果synchronized锁住整个方法,效率低,锁住的是整个类模板。
- 方式二:双重检验锁,线程安全
效率高写,可以使用双重检验锁机制:
class LazySingleton{
private static volatile LazySingleton instance;
public static LazySingleton getInstance() {
if (instance == null){
// 停留2秒,这样会有多个线程进到这里,即实例了n次,那就不是单例模式了
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 双重检验锁,锁住的是代码块,锁住类
synchronized (LazySingleton.class){
//再判断,防止上一个==null有多个线程进来
if (instance == null){
instance = new LazySingleton();
}
}
}
return instance;
}
}
这样还是会出现数据异常的情况,首先 instance = new LazySingleton();的底层汇编是:
- 分配空间,返回一个指向该空间的一个内存引用(堆空间)
- 对空间进行初始化
- 把内存引用赋值给instance
由于存在编译器指令重排的情况,以上顺序会出现不一致,会出现这种情况:1,3先执行,然后有其它线程访问第一个if (instance == null),结果发现不为空,直接return,这样那个线程就拿走了数据异常的实例,所以需要加volatile修饰instance,才不会有事,禁止指令重排。
饿汉模式在类加载阶段就完成了实例的初始化。
- 方式一:静态常量
类加载器加载到方法区的二进制文件,静态,常量。
原理是jvm的类加载器自动完成了static实例化。
步骤:1) 构造器私有化 (防止 new ) 2) 类的内部创建对象 3) 向外暴露一个静态的公共方法getInstance。
// 饿汉模式1静态常量
public class Hunger {
//私有static,实例一次
private static Hunger instance = new Hunger();
//向外暴露口
public static Hunger getInstance(){
return instance;
}
private Hunger(){
}
}
优缺点说明:
-
优点:这种写法比较简单,就是在类装载的时候就完成实例化。避免了线程同步问题。
-
缺点:在类装载的时候就完成实例化,没有达到 Lazy Loading 的效果。如果从始至终从未使用过这个实例,则会造成内存的浪费
-
这种方式基于 classloder 机制避免了多线程的同步问题,不过,instance 在类装载时就实例化,在单例模式中大多数都是调用 getInstance 方法, 但是导致类装载的原因有很多种,因此不能确定有其他的方式(或者其他的静态方法)导致类装载,这时候初始化 instance 就没有达到 lazy loading 的效果
-
结论:这种单例模式可用,可能造成内存浪费
序列化测试:
// 序列化,持久到磁盘,按对象字节,ObjectOutputStream,ObjectInputStream
// 默认指定序列化id,不然不能重新输出到同一个文件
public class SerializeTest {
public static void main(String[] args) throws IOException, ClassNotFoundException {
Hunger instance = Hunger.getInstance();
ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("instance"));
outputStream.writeObject(instance);
outputStream.close();
ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("instance"));
Hunger instance2 = (Hunger)inputStream.readObject();
inputStream.close();
System.out.println(instance == instance2); // false,多个实例
}
}
输出false,说明不是单例了,解决方法如下:
// 饿汉模式
public class Hunger implements Serializable {
private final static long serialVersionUID = 8391757654242165401L;
private static Hunger instance = new Hunger();
public static Hunger getInstance(){
return instance;
}
private Hunger(){
}
// 解决反序列化单例问题
Object readResolve() throws ObjectStreamException{
return instance;
}
}
- 方式二:静态代码块
// 饿汉模式2静态代码块
public class Hunger {
//私有static
private static Hunger instance;
//静态代码块实例
static{
instance = new Hunger();
}
//向外暴露口
public static Hunger getInstance(){
return instance;
}
private Hunger(){
}
}
-
这种方式和上面的方式其实类似,只不过将类实例化的过程放在了静态代码块中,也是在类装载的时候,就执行静态代码块中的代码,初始化类的实例。优缺点和上面是一样的。
-
结论:这种单例模式可用,但是可能造成内存浪费
一样在类加载阶段就完成了实例的初始化
// 内部类
public class InnerClass {
static class inner{
private static final InnerClass instance = new InnerClass();
}
public static InnerClass getInstance(){
return inner.instance;
}
private InnerClass(){
}
}
public class Test {
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
// 反射获取
Constructor innerClass = InnerClass.class.getDeclaredConstructor();
// 暴力方式
innerClass.setAccessible(true);
InnerClass instance1 = innerClass.newInstance();
InnerClass instance2 = InnerClass.getInstance();
System.out.println(instance1 == instance2); // false 2个实例
}
}
静态内部类方式在 Singleton 类被装载时并不会立即实例化,而是在需要实例化时,调用 getInstance 方法,才会装载 SingletonInstance 类,从而完成 Singleton 的实例化。
类的静态属性只会在第一次加载类的时候初始化,所以在这里,JVM 帮助我们保证了线程的安全性,在类进行初始化时,别的线程是无法进入的。
以上使用static静态方式实现,存在弊端,我们用反射暴力获取实例时,出现多个实例了,违反单例模式。
需要调整构造函数InnerClass():
// 内部类
public class InnerClass {
static class inner{
private static InnerClass instance = new InnerClass();
}
public static InnerClass getInstance(){
return inner.instance;
}
private InnerClass(){
if (getInstance() != null){
throw new RuntimeException("不能多个实例");
}
}
}
枚举单例
枚举可以防止反序列化重新创建新的对象。
//枚举方式
public enum EnumTest {
INSTANCE;
public void print(){
System.out.println(this.hashCode());
}
}
底层枚举类型不能通过反射实例化,默认符合单例。
EnumTest instance1 = EnumTest.INSTANCE; EnumTest instance2 = EnumTest.INSTANCE; System.out.println(instance1 == instance2); //true instance1.print(); // 一样 instance2.print();单例模式在 JDK 应用的源码分析
- 我们 JDK 中,java.lang.Runtime 就是经典的单例模式(饿汉式)
2)代码分析+Debug源码代码说明
单例模式注意事项和细节说明-
单例模式保证了 系统内存中该类只存在一个对象,节省了系统资源,对于一些需要频繁创建销毁的对象,使用单例模式可以提高系统性能
-
当想实例化一个单例类的时候,必须要记住使用相应的获取对象的方法,而不是使用 new
-
单例模式使用的场景:需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多(即:重量级对象),但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象(比如数据源、session 工厂等)
推荐使用:双重锁、静态内部类、枚举



