java对象半初始化问题是怎么回事

背景: 最近无意间看到关于java对象半初始化问题，趁着周末今天聊聊java对象半初始化问题。

一、前言

1. 什么是Java对象半初始化

Java对象的创建过程包括内存分配、执行构造方法进行初始化和设置堆内存中的引用地址。在多线程环境下，由于Java内存模型允许指令的重排序，可能导致一个线程看到了另一个线程创建的对象的引用地址，但是这个对象还没有完成初始化。此时，我们称这个对象为半初始化对象。

2. 对象半初始化问题引发的影响

对象半初始化问题可能导致多线程环境下程序的行为异常，比如：

• 线程安全问题 一个线程在使用尚未初始化完成的对象时可能导致数据不一致或程序崩溃。
• 可见性问题 多个线程在访问半初始化对象时可能看到不一致的状态，导致程序逻辑错误。
• 内存泄漏 半初始化对象可能导致内存泄漏，因为在垃圾回收时，半初始化对象可能被误认为是可达对象。

二、对象半初始化问题详解

1. Java对象创建过程

• 分配内存空间：为新对象分配内存空间，通常在堆（Heap）中进行。此时，分配给对象的内存地址都是默认值，如0、false、null等。
• 初始化对象：执行构造方法进行初始化，完成对象的状态设置。此阶段会按照程序员的意愿设置对象的属性值。
• 堆内存中设置引用地址：将对象的引用地址设置到变量上，使得程序可以访问和操作对象。

2. 对象半初始化问题产生的原因

• Java内存模型：Java内存模型允许指令的重排序，即构造函数的执行顺序可以与代码编写的顺序不一致。这是为了提高处理器和编译器的执行效率。然而，在多线程环境下，这种优化可能导致对象半初始化问题。
• 重排序导致的问题：由于指令重排序，可能导致一个线程看到了另一个线程创建的对象的引用地址，但这个对象还没有完成初始化，从而导致对象半初始化问题。以下是一个简单的例子：

public class Example {
    
    
    private static Example instance;
    private int value;

    private Example() {
    
    
        value = 10;
    }

    public static Example getInstance() {
    
    
        if (instance == null) {
    
    
            instance = new Example();
        }
        return instance;
    }

    public int getValue() {
    
    
        return value;
    }
}

Example 类是一个单例类，通过 getInstance() 方法获取唯一的实例。由于指令重排序，可能出现以下执行顺序：

1. 分配内存空间
2. 堆内存中设置引用地址（此时 instance 不为 null 了，但对象还没有完成初始化）
3. 初始化对象

在多线程环境下，如果线程A在执行getInstance()方法时，在第2步和第3步之间，线程B也开始执行getInstance()方法。此时，线程B发现instance 不为 null，于是直接返回instance，但此时instance指向的对象尚未完成初始化。这样，线程B就会访问半初始化的对象。

为了避免这种情况，可以使用双重检查锁定（Double-Checked Locking）的方法：

public static Example getInstance() {
    
    
    if (instance == null) {
    
    
        synchronized (Example.class) {
    
    
            if (instance == null) {
    
    
                instance = new Example();
            }
        }
    }
    return instance;
}

但是，这种方法仍然可能会遇到对象半初始化问题。为了彻底解决该问题，需要使用volatile关键字：

private static volatile Example instance;

使用volatile关键字可以禁止指令重排序，确保对象在分配内存空间、初始化对象和设置堆内存中的引用地址的顺序不被打乱。这样就可以避免对象半初始化问题。

三、实例分析：对象半初始化问题的表现

1. 单线程环境下的半初始化

在单线程环境下，由于没有并发操作，对象的初始化通常是按照预定的顺序进行的，因此很少出现半初始化的情况。但是，在某些特殊情况下，例如循环依赖或者异常处理中，仍然可能出现对象半初始化的问题。

例如，以下的代码中，由于构造函数中的自引用创建了一个循环依赖，导致对象在初始化过程中产生了一个半初始化的自引用。

public class Example {
    
    
    private Example self;

    public Example() {
    
    
        // 在对象初始化过程中创建一个自引用
        self = this;
    }

    public void check() {
    
    
        if (self != null) {
    
    
            System.out.println("Object is partially initialized!");
        }
    }
}

public static void main(String[] args) {
    
    
    Example example = new Example();
    example.check();
}

在这个例子中，check() 方法会打印出 “Object is partially initialized!”，因为当它被调用时，self 引用的对象还处在初始化过程中。

2. 多线程环境下的半初始化

在多线程环境下，由于线程的并发执行和指令的重排序，很容易导致对象半初始化的问题。尤其是在使用单例模式或者延迟初始化的时候，这种问题更加明显。

例如，以下的代码中，尽管使用了双重检查锁定，但是由于指令重排序，其他线程仍然可能看到一个半初始化的单例对象。

public class Singleton {
    
    
    private static Singleton instance;
    private SomeObject obj;

    private Singleton() {
    
    
        obj = new SomeObject();
    }

    public static Singleton getInstance() {
    
    
        if (instance == null) {
    
    
            synchronized (Singleton.class) {
    
    
                if (instance == null) {
    
    
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

    public SomeObject getObj() {
    
    
        return obj;
    }
}

public static void main(String[] args) {
    
    
    // 创建多个线程并发获取单例对象
    for (int i = 0; i < 10; i++) {
    
    
        new Thread(() -> {
    
    
            Singleton singleton = Singleton.getInstance();
            // 检查获取到的单例对象是否初始化完全
            if (singleton.getObj() == null) {
    
    
                System.out.println("Singleton is partially initialized!");
            }
        }).start();
    }
}

多个线程并发执行 getInstance() 方法，可能会看到一个半初始化的 Singleton 对象，即 obj 属性可能为 null。

四、解决方案及防范措施

1. 禁止指令重排序

• 使用final关键字：在多线程环境中，final关键字可以保证初始化完成的可见性，防止对象在被初始化完成之前被其他线程所引用。
• 使用构造函数私有化：私有化构造函数可以强制用户通过特定的方式创建对象，从而防止用户在未完成初始化的情况下获取对象的引用。

2. 使用安全发布对象的模式

• 使用不可变对象：不可变对象一旦被初始化，其状态就不能被改变，这样就可以保证没有其他线程可以看到对象在被初始化过程中的状态。
• 使用volatile关键字：volatile关键字可以保证多线程环境下变量的可见性和禁止指令重排序，从而防止对象半初始化的问题。

3. 在实际编程中，应尽量避免在构造函数中引用自身或暴露自身的引用，防止逸出引起的问题。

4. 对于单例对象，可以通过内部类的方式来实现，既能保证线程安全，又能保证单例对象的唯一性。

例如：

public class Singleton {
    
    
    private Singleton() {
    
    
        // do something
    }

    private static class SingletonHolder {
    
    
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
    
    
        return SingletonHolder.INSTANCE;
    }
}

Singleton 的初始化被推迟到了 SingletonHolder 类被真正的加载时才执行，同时由 JVM 来保证线程安全和单一性。

5.参考文档

1. 《Java Memory Model》https://docs.oracle.com/javase/specs/jls/se8/html/jls-17.html
2. Java Tutorials - Concurrency.https://docs.oracle.com/javase/tutorial/essential/concurrency/
3. 《java内部模型》https://www.cnblogs.com/nexiyi/p/java_memory_model_and_thread.html