// runtime/objc-runtime-new.h：状态位只属于运行时，不由编译器写入。
#define RW_INITIALIZED   (1<<29)  // 类已经完成 +initialize
#define RW_INITIALIZING  (1<<28)  // 类正在执行 +initialize

bool isInitializing() const {
    return getMetaFlags() & RW_INITIALIZING;  // 从元类读取状态
}

void setInitializing() {
    ASSERT(!isMetaClass());      // 调用者传入非元类
    ISA()->setInfo(RW_INITIALIZING); // 但状态写到元类上
}

bool isInitialized() const {
    return getMetaFlags() & RW_INITIALIZED;   // 同样从元类读取
}

// runtime/objc-runtime-new.mm：压缩后的入口逻辑。
static Class initializeAndMaybeRelock(Class cls, id inst,
                                      mutex_t& lock, bool leaveLocked)
{
    lockdebug::assert_locked(&lock);

    cls->realizeIfNeeded_nolock();   // 初始化前先确保类已 realize

    if (cls->isInitialized()) {      // 快速路径：别人已经完成
        if (!leaveLocked) lock.unlock();
        return cls;
    }

    Class nonmeta = getMaybeUnrealizedNonMetaClass(cls, inst);
    // +initialize 总是发送给非元类对象，即使触发点来自元类。

    if (nonmeta->isRealized()) {
        lock.unlock();               // 用户 +initialize 不能在 runtimeLock 下执行
    } else {
        nonmeta = realizeClassMaybeSwiftAndUnlock(nonmeta, lock);
    }

    initializeNonMetaClass(nonmeta); // 真正的并发状态机

    if (leaveLocked) runtimeLock.lock();
    return cls;
}

// runtime/objc-initialize.mm：保留核心分支的伪源码。
void initializeNonMetaClass(Class cls)
{
    ASSERT(!cls->isMetaClass());

    Class supercls = cls->getSuperclass();
    if (supercls && !supercls->isInitialized()) {
        initializeNonMetaClass(supercls);
        // 父类必须在子类开始前完成，避免两个线程从继承链中间互等。
    }

    lockClass(cls);                  // 每类递归锁；其他线程会在这里等待

    if (cls->isInitialized()) {      // 等锁期间已由别的线程完成
        unlockClass(cls);
        return;
    }

    if (cls->isInitializing()) {     // 已经处于初始化中
        if (!MultithreadedForkChild || _thisThreadIsInitializingClass(cls)) {
            unlockClass(cls);        // 本线程重入：允许继续发消息
            return;
        } else {
            lockClass(cls);          // fork 子进程特殊恢复，见下文
            _setThisThreadIsInitializingClass(cls);
            performForkChildInitialize(cls, supercls);
        }
    }

    {
        mutex_locker_t lock(classInitLock);
        cls->setInitializing();      // INITIALIZING=1，INITIALIZED=0
        localWillInitializeFuncs.initFrom(willInitializeFuncs);
    }

    _setThisThreadIsInitializingClass(cls);
    // 从这里开始，本线程可以向该类发消息而不等待自己。

    @try {
        callInitialize(cls);         // objc_msgSend(cls, @selector(initialize))
    } @catch (...) {
        @throw;                      // 异常继续向外抛
    } @finally {
        lockAndFinishInitializing(cls, supercls);
        // 无论正常返回还是抛异常，都认为本次初始化流程已完成。
    }
}

// runtime/objc-runtime-new.mm：完成态切换。
void objc_class::setInitialized()
{
    ASSERT(!isMetaClass());

    Class cls = (Class)this;
    Class metacls = cls->ISA();

    mutex_locker_t lock(runtimeLock);

    objc::Scanner::scanInitializedClass(cls, metacls);
    // 初始化完成后，运行时可以扫描 RR/AWZ/Core 等方法特征。

    metacls->changeInfo(RW_INITIALIZED, RW_INITIALIZING);
    // 关键状态转移：INITIALIZED=1，同时清掉 INITIALIZING。
}

// runtime/objc-initialize.mm：完成或挂起子类完成态。
static void lockAndFinishInitializing(Class cls, Class supercls)
{
    mutex_locker_t lock(pendingInitializeMapLock);

    if (!supercls || supercls->isInitialized()) {
        _finishInitializing(cls, supercls);
        // 父类已完成：设置 INITIALIZED，解开类锁，唤醒等待者。
    } else {
        _finishInitializingAfter(cls, supercls);
        // 父类仍在初始化：子类先进入 pending 表，等父类完成后再释放。
    }
}

static void _finishInitializing(Class cls, Class supercls)
{
    cls->setInitialized();           // INITIALIZING -> INITIALIZED
    unlockClass(cls);                // 等待该类初始化的线程可以继续
    _setThisThreadIsNotInitializingClass(cls);

    // 若有子类等本类完成，则递归标记那些子类完成。
    for (PendingInitialize *p = pendingInitializeMap[cls]; p; p = p->next) {
        _finishInitializing(p->subclass, cls);
    }
}

// runtime/objc-initialize.mm：fork 子进程中的保守规则。
void performForkChildInitialize(Class cls, Class supercls)
{
    if (classHasTrivialInitialize(cls)) {
        lockAndFinishInitializing(cls, supercls);
        // 没有真实用户 +initialize：可当作完成，避免无意义等待。
    } else {
        objc_initializeAfterForkError(cls);
        _objc_fatal("+[%s initialize] may have been in progress ...",
                    cls->nameForLogging());
        // 自定义 +initialize 可能在父进程其他线程执行到一半：崩溃比死锁或破坏状态更可控。
    }
}

void classInitializeAtforkChild() {
    foreachInitializingClass([](Class cls){
        lockClass(cls);
        // 子进程里的 objc_sync 锁已重建；当前线程正在初始化的类需要重新加锁。
    });
}