#define CHECK_FOR_FORK() do { __CF120290 = true; if (__CF120293) __THE_PROCESS_HAS_FORKED_AND_YOU_CANNOT_USE_THIS_COREFOUNDATION_FUNCTIONALITY___YOU_MUST_EXEC__(); } while (0)

void __CFInitialize(void) {
     if (!__CFInitialized && !__CFInitializing) {
        __CFInitializing = 1;
        // to do...

        // pthread_atfork(void (prepare)(void），void (parent)(void）, void(*child)(void))
        pthread_atfork(__01121__, NULL, __01123__);
     }
}

在RunTime的初始化方法中，通过pthread_atfork() 设置fork进程要执行的方法。

prepare（__01121__）在fork进程创建子进程（__01123__）前调用，并能获取到所有锁；

child 创建后对所有锁进行解锁；

//多进程判断
static void __01121__(void) {
    __CF120291 = pthread_is_threaded_np() ? true : false;
}

static void __01123__(void) {
    // Ideally, child-side atfork handlers should be async-cancel-safe, as fork()
    // is async-cancel-safe and can be called from signal handlers.  See also
    // http://standards.ieee.org/reading/ieee/interp/1003-1c-95_int/pasc-1003.1c-37.html
    // This is not a problem for CF.
    if (__CF120290) {
	__CF120293 = true;
#if DEPLOYMENT_TARGET_MACOSX
	if (__CF120291) {
	    CRSetCrashLogMessage2("*** multi-threaded process forked ***");
	} else {
	    CRSetCrashLogMessage2("*** single-threaded process forked ***");
	}
#endif
    }
}

__CF120290 控制fork进程能否赋值

__CF120293 fork进程标识

#define EXEC_WARNING_STRING_1 "The process has forked and you cannot use this CoreFoundation functionality safely. You MUST exec().\n"
#define EXEC_WARNING_STRING_2 "Break on __THE_PROCESS_HAS_FORKED_AND_YOU_CANNOT_USE_THIS_COREFOUNDATION_FUNCTIONALITY___YOU_MUST_EXEC__() to debug.\n"

CF_PRIVATE void __THE_PROCESS_HAS_FORKED_AND_YOU_CANNOT_USE_THIS_COREFOUNDATION_FUNCTIONALITY___YOU_MUST_EXEC__(void) {
    write(2, EXEC_WARNING_STRING_1, sizeof(EXEC_WARNING_STRING_1) - 1);
    write(2, EXEC_WARNING_STRING_2, sizeof(EXEC_WARNING_STRING_2) - 1);
//    HALT;
}

当__CF120293 == true ,表明当前进程是fork的child。再使用CoreFoundation可能存在安全问题（子进程使用父进程数据），应该用exec()置换进程。

CF_EXPORT CFRunLoopRef _CFRunLoopGet0(pthread_t t) {
    // kNilPthreadT 是静态常量 ‘static _CFThreadRef const kNilPthreadT = (_CFThreadRef)0;‘
    // t 主线程
    if (pthread_equal(t, kNilPthreadT)) {
	t = pthread_main_thread_np();
    }
    __CFLock(&loopsLock);
    if (!__CFRunLoops) {
        __CFUnlock(&loopsLock);
	CFMutableDictionaryRef dict = CFDictionaryCreateMutable(kCFAllocatorSystemDefault, 0, NULL, &kCFTypeDictionaryValueCallBacks);
        //主线程循环
	CFRunLoopRef mainLoop = __CFRunLoopCreate(pthread_main_thread_np());
        // 用利用key-value，将祝线程和runloop进行绑定
	CFDictionarySetValue(dict, pthreadPointer(pthread_main_thread_np()), mainLoop);
	if (!OSAtomicCompareAndSwapPtrBarrier(NULL, dict, (void * volatile *)&__CFRunLoops)) {
	    CFRelease(dict);
	}
	CFRelease(mainLoop);
        __CFLock(&loopsLock);
    }
    
    //查询其他线程中有无对应runloop
    CFRunLoopRef loop = (CFRunLoopRef)CFDictionaryGetValue(__CFRunLoops, pthreadPointer(t));
    __CFUnlock(&loopsLock);
    
    //没有获取到，要重新创建
    if (!loop) {
	CFRunLoopRef newLoop = __CFRunLoopCreate(t);
        __CFLock(&loopsLock);
        //二次验证，获取runloop
	loop = (CFRunLoopRef)CFDictionaryGetValue(__CFRunLoops, pthreadPointer(t));
	if (!loop) {
	    CFDictionarySetValue(__CFRunLoops, pthreadPointer(t), newLoop);
	    loop = newLoop;
	}
        // don't release run loops inside the loopsLock, because CFRunLoopDeallocate may end up taking it
        __CFUnlock(&loopsLock);
	CFRelease(newLoop);
    }
    if (pthread_equal(t, pthread_self())) {
        _CFSetTSD(__CFTSDKeyRunLoop, (void *)loop, NULL);
        if (0 == _CFGetTSD(__CFTSDKeyRunLoopCntr)) {
            _CFSetTSD(__CFTSDKeyRunLoopCntr, (void *)(PTHREAD_DESTRUCTOR_ITERATIONS-1), (void (*)(void *))__CFFinalizeRunLoop);
        }
    }
    return loop;
}