//    全局字典，用来存放线程对应的RunLoop

//    key是线程，value是RunLoop实例，换言之线程与RunLoopRunLoop一一对应

    static CFMutableDictionaryRef __CFRunLoops = NULL;

    static CFSpinLock_t loopsLock = CFSpinLockInit;

    // 当t == 0 的时候，代表主线程

    CF_EXPORT CFRunLoopRef _CFRunLoopGet0(pthread_t t) {

//        如果存进来的线程等于 0

        if (pthread_equal(t, kNilPthreadT)) {

//            那么当前线程等于主线程

            t = pthread_main_thread_np();

        }

//        给操作加锁

        __CFSpinLock(&loopsLock);

//        如果当前RunLoop没有为空，创建。

        if (!__CFRunLoops) {

            __CFSpinUnlock(&loopsLock);

            CFMutableDictionaryRef dict = CFDictionaryCreateMutable(kCFAllocatorSystemDefault, , NULL, &kCFTypeDictionaryValueCallBacks);

            CFRunLoopRef mainLoop = __CFRunLoopCreate(pthread_main_thread_np());

//            把线程与RunLoop一一对应的存进字典

            CFDictionarySetValue(dict, pthreadPointer(pthread_main_thread_np()), mainLoop);

            if (!OSAtomicCompareAndSwapPtrBarrier(NULL, dict, (void * volatile *)&__CFRunLoops)) {

                CFRelease(dict);

            }

            CFRelease(mainLoop);

            __CFSpinLock(&loopsLock);

        }

//        获取当前线程的RunLoop

        CFRunLoopRef loop = (CFRunLoopRef)CFDictionaryGetValue(__CFRunLoops, pthreadPointer(t));

        __CFSpinUnlock(&loopsLock);

//        如果不是主线程并且之前没有创建，也即是为空

        if (!loop) {

            CFRunLoopRef newLoop = __CFRunLoopCreate(t);

            __CFSpinLock(&loopsLock);

            loop = (CFRunLoopRef)CFDictionaryGetValue(__CFRunLoops, pthreadPointer(t));

            if (!loop) {

//                把当前子线程和创建的RunLoop一一对应的存进字典

                CFDictionarySetValue(__CFRunLoops, pthreadPointer(t), newLoop);

                loop = newLoop;

            }

            // don't release run loops inside the loopsLock, because CFRunLoopDeallocate may end up taking it

            __CFSpinUnlock(&loopsLock);

            CFRelease(newLoop);

        }

        if (pthread_equal(t, pthread_self())) {

            _CFSetTSD(__CFTSDKeyRunLoop, (void *)loop, NULL);

            if ( == _CFGetTSD(__CFTSDKeyRunLoopCntr)) {

                _CFSetTSD(__CFTSDKeyRunLoopCntr, (void *)(PTHREAD_DESTRUCTOR_ITERATIONS-), (void (*)(void *))__CFFinalizeRunLoop);

            }

        }

        return loop;

    }

　　 CFRunLoopAddSource(CFRunLoopRef rl, CFRunLoopSourceRef source, CFStringRef modeName);

    CFRunLoopAddObserver(CFRunLoopRef rl, CFRunLoopObserverRef observer, CFStringRef modeName);

    CFRunLoopAddTimer(CFRunLoopRef rl, CFRunLoopTimerRef timer, CFStringRef mode);

    CFRunLoopRemoveSource(CFRunLoopRef rl, CFRunLoopSourceRef source, CFStringRef modeName);

    CFRunLoopRemoveObserver(CFRunLoopRef rl, CFRunLoopObserverRef observer, CFStringRef modeName);

    CFRunLoopRemoveTimer(CFRunLoopRef rl, CFRunLoopTimerRef timer, CFStringRef mode);

/// 用DefaultMode启动

void CFRunLoopRun(void) {

    CFRunLoopRunSpecific(CFRunLoopGetCurrent(), kCFRunLoopDefaultMode, 1.0e10, false);

}

/// 用指定的Mode启动，允许设置RunLoop超时时间

int CFRunLoopRunInMode(CFStringRef modeName, CFTimeInterval seconds, Boolean stopAfterHandle) {

    return CFRunLoopRunSpecific(CFRunLoopGetCurrent(), modeName, seconds, returnAfterSourceHandled);

}

/// RunLoop的实现

int CFRunLoopRunSpecific(runloop, modeName, seconds, stopAfterHandle) {

    /// 首先根据modeName找到对应mode

    CFRunLoopModeRef currentMode = __CFRunLoopFindMode(runloop, modeName, false);

    /// 如果mode里没有source/timer/observer, 直接返回。

    if (__CFRunLoopModeIsEmpty(currentMode)) return;

    /// 1. 通知 Observers: RunLoop 即将进入 loop。

    __CFRunLoopDoObservers(runloop, currentMode, kCFRunLoopEntry);

    /// 内部函数，进入loop

    __CFRunLoopRun(runloop, currentMode, seconds, returnAfterSourceHandled) {

        Boolean sourceHandledThisLoop = NO;

        int retVal = ;

        do {

            /// 2. 通知 Observers: RunLoop 即将触发 Timer 回调。

            __CFRunLoopDoObservers(runloop, currentMode, kCFRunLoopBeforeTimers);

            /// 3. 通知 Observers: RunLoop 即将触发 Source0 (非port) 回调。

            __CFRunLoopDoObservers(runloop, currentMode, kCFRunLoopBeforeSources);

            /// 执行被加入的block

            __CFRunLoopDoBlocks(runloop, currentMode);

            /// 4. RunLoop 触发 Source0 (非port) 回调。

            sourceHandledThisLoop = __CFRunLoopDoSources0(runloop, currentMode, stopAfterHandle);

            /// 执行被加入的block

            __CFRunLoopDoBlocks(runloop, currentMode);

            /// 5. 如果有 Source1 (基于port) 处于 ready 状态，直接处理这个 Source1 然后跳转去处理消息。

            if (__Source0DidDispatchPortLastTime) {

                Boolean hasMsg = __CFRunLoopServiceMachPort(dispatchPort, &msg)

                if (hasMsg) goto handle_msg;

            }

            /// 通知 Observers: RunLoop 的线程即将进入休眠(sleep)。

            if (!sourceHandledThisLoop) {

                __CFRunLoopDoObservers(runloop, currentMode, kCFRunLoopBeforeWaiting);

            }

            /// 7. 调用 mach_msg 等待接受 mach_port 的消息。线程将进入休眠, 直到被下面某一个事件唤醒。

            /// ? 一个基于 port 的Source 的事件。

            /// ? 一个 Timer 到时间了

            /// ? RunLoop 自身的超时时间到了

            /// ? 被其他什么调用者手动唤醒

            __CFRunLoopServiceMachPort(waitSet, &msg, sizeof(msg_buffer), &livePort) {

                mach_msg(msg, MACH_RCV_MSG, port); // thread wait for receive msg

            }

            /// 8. 通知 Observers: RunLoop 的线程刚刚被唤醒了。

            __CFRunLoopDoObservers(runloop, currentMode, kCFRunLoopAfterWaiting);

            /// 收到消息，处理消息。

            handle_msg:

            /// 9.1 如果一个 Timer 到时间了，触发这个Timer的回调。

            if (msg_is_timer) {

                __CFRunLoopDoTimers(runloop, currentMode, mach_absolute_time())

            }

            /// 9.2 如果有dispatch到main_queue的block，执行block。

            else if (msg_is_dispatch) {

                __CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__(msg);

            }

            /// 9.3 如果一个 Source1 (基于port) 发出事件了，处理这个事件

            else {

                CFRunLoopSourceRef source1 = __CFRunLoopModeFindSourceForMachPort(runloop, currentMode, livePort);

                sourceHandledThisLoop = __CFRunLoopDoSource1(runloop, currentMode, source1, msg);

                if (sourceHandledThisLoop) {

                    mach_msg(reply, MACH_SEND_MSG, reply);

                }

            }

            /// 执行加入到Loop的block

            __CFRunLoopDoBlocks(runloop, currentMode);

            if (sourceHandledThisLoop && stopAfterHandle) {

                /// 进入loop时参数说处理完事件就返回。

                retVal = kCFRunLoopRunHandledSource;

            } else if (timeout) {

                /// 超出传入参数标记的超时时间了

                retVal = kCFRunLoopRunTimedOut;

            } else if (__CFRunLoopIsStopped(runloop)) {

                /// 被外部调用者强制停止了

                retVal = kCFRunLoopRunStopped;

            } else if (__CFRunLoopModeIsEmpty(runloop, currentMode)) {

                /// source/timer/observer一个都没有了

                retVal = kCFRunLoopRunFinished;

            }

            /// 如果没超时，mode里没空，loop也没被停止，那继续loop。

        } while (retVal == );

    }

    /// 10. 通知 Observers: RunLoop 即将退出。

    __CFRunLoopDoObservers(rl, currentMode, kCFRunLoopExit);

}

    typedef struct {

  mach_msg_header_t header;

  mach_msg_body_t body;

    } mach_msg_base_t;

typedef struct {

  mach_msg_bits_t msgh_bits;

  mach_msg_size_t msgh_size;

  mach_port_t msgh_remote_port;

  mach_port_t msgh_local_port;

  mach_port_name_t msgh_voucher_port;

  mach_msg_id_t msgh_id;

    } mach_msg_header_t;

{

/// 1. 通知Observers，即将进入RunLoop

/// 此处有Observer会创建AutoreleasePool:                         _objc_autoreleasePoolPush();

__CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION_    _(kCFRunLoopEntry);

do {

    /// 2. 通知 Observers: 即将触发 Timer 回调。

    __CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION__(kCFRunLoopBeforeTimers);

    /// 3. 通知 Observers: 即将触发 Source (非基于port的,Source0) 回调。

    __CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION__(kCFRunLoopBeforeSources);

    __CFRUNLOOP_IS_CALLING_OUT_TO_A_BLOCK__(block);

    /// 4. 触发 Source0 (非基于port的) 回调。

    __CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE0_PERFORM_FUNCTION__(source0);

    __CFRUNLOOP_IS_CALLING_OUT_TO_A_BLOCK__(block);

    /// 6. 通知Observers，即将进入休眠

    /// 此处有Observer释放并新建AutoreleasePool:     _objc_autoreleasePoolPop(); _objc_autoreleasePoolPush();

    __CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION__(kCFRunLoopBeforeWaiting);

    /// 7. sleep to wait msg.

    mach_msg() -> mach_msg_trap();

    /// 8. 通知Observers，线程被唤醒

    __CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION__(kCFRunLoopAfterWaiting);

    /// 9. 如果是被Timer唤醒的，回调Timer

    __CFRUNLOOP_IS_CALLING_OUT_TO_A_TIMER_CALLBACK_FUNCTION__(timer);

    /// 9. 如果是被dispatch唤醒的，执行所有调用 dispatch_async 等方法放入main queue 的 block

    __CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__(dispatched_block);

    /// 9. 如果如果Runloop是被 Source1 (基于port的) 的事件唤醒了，处理这个事件

    __CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE1_PERFORM_FUNCTION__(source1);

} while (...);

/// 10. 通知Observers，即将退出RunLoop

/// 此处有Observer释放AutoreleasePool: _objc_autoreleasePoolPop();

__CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION__(kCFRunLoopExit);

}

_ZN2CA11Transaction17observer_callbackEP19__CFRunLoopObservermPv()

    QuartzCore:CA::Transaction::observer_callback:

        CA::Transaction::commit();

            CA::Context::commit_transaction();

                CA::Layer::layout_and_display_if_needed();

                    CA::Layer::layout_if_needed();

                        [CALayer layoutSublayers];

                            [UIView layoutSubviews];

                    CA::Layer::display_if_needed();

                        [CALayer display];

                            [UIView drawRect];

CFSocket

CFNetwork       ->ASIHttpRequest

NSURLConnection ->AFNetworking

NSURLSession    ->AFNetworking2, Alamofire

+ (void)networkRequestThreadEntryPoint:(id)__unused object {

    @autoreleasepool {

        [[NSThread currentThread] setName:@"AFNetworking"];

        NSRunLoop *runLoop = [NSRunLoop currentRunLoop];

        [runLoop addPort:[NSMachPort port] forMode:NSDefaultRunLoopMode];

        [runLoop run];

    }

}

+ (NSThread *)networkRequestThread {

    static NSThread *_networkRequestThread = nil;

    static dispatch_once_t oncePredicate;

    dispatch_once(&oncePredicate, ^{

        _networkRequestThread = [[NSThread alloc] initWithTarget:self selector:@selector(networkRequestThreadEntryPoint:) object:nil];

        [_networkRequestThread start];

    });

    return _networkRequestThread;

}

- (void)start {

    [self.lock lock];

    if ([self isCancelled]) {

        [self performSelector:@selector(cancelConnection) onThread:[[self class] networkRequestThread] withObject:nil waitUntilDone:NO modes:[self.runLoopModes allObjects]];

    } else if ([self isReady]) {

        self.state = AFOperationExecutingState;

        [self performSelector:@selector(operationDidStart) onThread:[[self class] networkRequestThread] withObject:nil waitUntilDone:NO modes:[self.runLoopModes allObjects]];

    }

    [self.lock unlock];

}

    CFRunLoopObserverRef observer = CFRunLoopObserverCreateWithHandler(CFAllocatorGetDefault(), kCFRunLoopAllActivities, YES, , ^(CFRunLoopObserverRef observer, CFRunLoopActivity activity) {

    });

    CFRunLoopAddObserver(CFRunLoopGetCurrent(), observer, kCFRunLoopDefaultMode);

    [[NSRunLoop currentRunLoop] run];

- (void)viewDidLoad {

    [super viewDidLoad];

    NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(run:) object:@"etund"];

    self.thread = thread;

    NSLog(@"-----%p",[NSRunLoop currentRunLoop]);

    [self.thread start];

}

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event{

    [self performSelector:@selector(test) onThread:self.thread withObject:nil waitUntilDone:NO];

}

- (void)run:(NSString *)name{

    NSLog(@"==========");

}

- (void)test{

    NSLog(@"------------------");

}

- (void)run:(NSString *)name{

    [[NSRunLoop currentRunLoop] addPort:[[NSPort alloc] init] forMode:NSDefaultRunLoopMode]; //

    [[NSRunLoop currentRunLoop] run];

}

//    获取队列

    dispatch_queue_t queue = dispatch_get_main_queue();

//    创建定时器

    self.timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, , , queue);

//    设置定时器属性(什么时候开始，间隔多大)

//    定义开始时间

    dispatch_time_t start = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1.0 * NSEC_PER_SEC));

//    定义时间间隔

    uint64_t interver = (uint64_t)(1.0 * NSEC_PER_SEC);

//    设置开始时间和时间间隔

    dispatch_source_set_timer(self.timer, start,interver, );

//    设置回调

    dispatch_source_set_event_handler(self.timer, ^{

        NSLog(@"==================") ;

    });

//        dispatch_cancel(self.timer);

//        self.timer = nil;

//    取消定时器

//    启动定时器

    dispatch_resume(self.timer);