紫荆秋雪_文
紫荆秋雪_文

RunLoop

RunLoop顾名思义运行循环，在程序运行过程中循环做一些事情，比如：定时器（NSTimer）、GCD Async Main Queue、事件响应、手势识别、界面刷新、网络请求、AutoreleasePool；在没有RunLoop时，程序会立刻退出（比如创建的命令行项目）

一、RunLoop与线程

每条线程都有唯一的一个与之对应的RunLoop对象；RunLoop保存在一个全局的Dictionary里，线程作为key，RunLoop作为value；线程刚创建时并没有RunLoop对象，RunLoop会在第一次获取它时创建；RunLoop会在线程结束时销毁；主线程的RunLoop已经自动获取（创建），子线程默认没有开启RunLoop

  • iOS中有2套API来访问和使用RunLoop
    • Foundation：NSRunLoop
    • Core Foundation：CFRunLoopRef
    • NSRunLoop是基于CFRunLoopRef的一层OC包装
  • CFRunLoopRef源码
  • 常用获取RunLoop的API
    //获取当前线程RunLoop
    [NSRunLoop currentRunLoop];
    CFRunLoopGetCurrent();
    
    //获取主线程RunLoop
    [NSRunLoop mainRunLoop];
    CFRunLoopGetMain();

二、RunLoop

Core Foundation中与RunLoop相关的5个类

  • CFRunLoopRef
  • CFRunLoopModeRef
  • CFRunLoopSourceRef
  • CFRunLoopTimerRef
  • CFRunLoopObserverRef

typedef struct CF_BRIDGED_MUTABLE_TYPE(id) __CFRunLoop * CFRunLoopRef;

typedef struct CF_BRIDGED_MUTABLE_TYPE(id) __CFRunLoopSource * CFRunLoopSourceRef;

typedef struct CF_BRIDGED_MUTABLE_TYPE(id) __CFRunLoopObserver * CFRunLoopObserverRef;

typedef struct CF_BRIDGED_MUTABLE_TYPE(NSTimer) __CFRunLoopTimer * CFRunLoopTimerRef;
  • __CFRunLoop结构
struct __CFRunLoop {
    CFRuntimeBase _base;
    pthread_mutex_t _lock;          /* locked for accessing mode list */
    __CFPort _wakeUpPort;           // used for CFRunLoopWakeUp 
    Boolean _unused;
    volatile _per_run_data *_perRunData;              // reset for runs of the run loop
    pthread_t _pthread;
    uint32_t _winthread;
    CFMutableSetRef _commonModes; //集合，存放commonMode
    CFMutableSetRef _commonModeItems; //集合，存放选择commonMode中任务
    CFRunLoopModeRef _currentMode; //当前的mode类型
    CFMutableSetRef _modes; //集合，存储mode
    struct _block_item *_blocks_head;
    struct _block_item *_blocks_tail;
    CFAbsoluteTime _runTime;
    CFAbsoluteTime _sleepTime;
    CFTypeRef _counterpart;
}
  • __CFRunLoopMode结构
struct __CFRunLoopMode {
    CFRuntimeBase _base;
    pthread_mutex_t _lock;  /* must have the run loop locked before locking this */
    CFStringRef _name;
    Boolean _stopped;
    char _padding[3];
    CFMutableSetRef _sources0; //集合，source0
    CFMutableSetRef _sources1;  //集合，source1
    CFMutableArrayRef _observers; //集合，observer
    CFMutableArrayRef _timers; //集合，timer
    CFMutableDictionaryRef _portToV1SourceMap;
    __CFPortSet _portSet;
    CFIndex _observerMask;
#if USE_DISPATCH_SOURCE_FOR_TIMERS
    dispatch_source_t _timerSource;
    dispatch_queue_t _queue;
    Boolean _timerFired; // set to true by the source when a timer has fired
    Boolean _dispatchTimerArmed;
#endif
#if USE_MK_TIMER_TOO
    mach_port_t _timerPort;
    Boolean _mkTimerArmed;
#endif
#if DEPLOYMENT_TARGET_WINDOWS
    DWORD _msgQMask;
    void (*_msgPump)(void);
#endif
    uint64_t _timerSoftDeadline; /* TSR */
    uint64_t _timerHardDeadline; /* TSR */
}
  • __CFRunLoopSource结构
struct __CFRunLoopSource {
    CFRuntimeBase _base;
    uint32_t _bits;
    pthread_mutex_t _lock;
    CFIndex _order;         /* immutable */
    CFMutableBagRef _runLoops;
    union {
    CFRunLoopSourceContext version0;    /* immutable, except invalidation */
        CFRunLoopSourceContext1 version1;   /* immutable, except invalidation */
    } _context;
}
  • __CFRunLoopObserver结构
struct __CFRunLoopObserver {
    CFRuntimeBase _base;
    pthread_mutex_t _lock;
    CFRunLoopRef _runLoop;
    CFIndex _rlCount;
    CFOptionFlags _activities;      /* immutable */
    CFIndex _order;         /* immutable */
    CFRunLoopObserverCallBack _callout; /* immutable */
    CFRunLoopObserverContext _context;  /* immutable, except invalidation */
}
  • __CFRunLoopTimer结构
struct __CFRunLoopTimer {
    CFRuntimeBase _base;
    uint16_t _bits;
    pthread_mutex_t _lock;
    CFRunLoopRef _runLoop;
    CFMutableSetRef _rlModes;
    CFAbsoluteTime _nextFireDate;
    CFTimeInterval _interval;       /* immutable */
    CFTimeInterval _tolerance;          /* mutable */
    uint64_t _fireTSR;          /* TSR units */
    CFIndex _order;         /* immutable */
    CFRunLoopTimerCallBack _callout;    /* immutable */
    CFRunLoopTimerContext _context; /* immutable, except invalidation */
}

RunLoop中5个类之间的关系
RunLoop_第1张图片
RunLoop.png

  • 1、CFRunLoopRef：RunLoop对象
  • 2、CFRunLoopModeRef：RunLoop的运行模式
    • 一个RunLoop包含多个Mode，每个Mode中包含多个Source0/Source1/Timer/Observer
    • RunLoop只能选择其中一个Mode，作为currentMode
    • 如果需要切换Mode，只能退出当前Mode，再重新选择一个Mode进入
    • 不同Mode的Source0/Source1/Timer/Observer是分割开来，互不影响
    • 如果Mode里没有任何Source0/Source1/Timer/Observer，RunLoop会立即退出
    • KCFRunLoopDefaultMode（NSDefaultRunLoopMode）：App的默认Mode，通常主线程是在这个Mode下运行
    • UITrackingRunLoopMode：界面跟踪Mode，用于ScrollView追踪触摸滑动，保证界面滑动时不受其他Mode影响
    • NSRunLoopCommonModes：其实这并不是一个真正的Mode模式，它只是一个标记；使用NSRunLoopCommonModes后，timer或者任务可以在_commonModes集合中存放的模式下工作。NSDefaultRunLoopMode或者UITrackingRunLoopMode都是有NSRunLoopCommonModes标记的
  • 3、CFRunLoopObserverRef
typedef CF_OPTIONS(CFOptionFlags, CFRunLoopActivity) {
        kCFRunLoopEntry = (1UL << 0),           //即将进入RunLoop
        kCFRunLoopBeforeTimers = (1UL << 1),    //即将处理Timer
        kCFRunLoopBeforeSources = (1UL << 2),   //即将处理Source
        kCFRunLoopBeforeWaiting = (1UL << 5),   //即将进入休眠
        kCFRunLoopAfterWaiting = (1UL << 6),    //从休眠中唤醒
        kCFRunLoopExit = (1UL << 7),            //退出RunLoop
        kCFRunLoopAllActivities = 0x0FFFFFFFU
    }

RunLoop状态 & RunLoop Mode切换实践

1、RunLoop状态

  • 测试代码
#import "ViewController.h"

@interface ViewController ()

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    [self observerFun];
}


/**
 callback
 */
void runloopObserver(CFRunLoopObserverRef observer, CFRunLoopActivity activity, void *info) {
    switch (activity) {
        case kCFRunLoopEntry:
            NSLog(@"kCFRunLoopEntry");
            break;
        case kCFRunLoopBeforeTimers:
            NSLog(@"kCFRunLoopBeforeTimers");
            break;
        case kCFRunLoopBeforeSources:
            NSLog(@"kCFRunLoopBeforeSources");
            break;
        case kCFRunLoopBeforeWaiting:
            NSLog(@"kCFRunLoopBeforeWaiting");
            break;
        case kCFRunLoopAfterWaiting:
            NSLog(@"kCFRunLoopAfterWaiting");
            break;
        case kCFRunLoopExit:
            NSLog(@"kCFRunLoopExit");
            break;
        default:
            break;
    }
}


/**
 observer 方法回调
 */
- (void)observerFun {
    //创建observer
    CFRunLoopObserverRef observer = CFRunLoopObserverCreate(kCFAllocatorDefault, kCFRunLoopAllActivities, YES, 0, runloopObserver, NULL);
    //添加observer到RunLoop
    CFRunLoopAddObserver(CFRunLoopGetMain(), observer, kCFRunLoopDefaultMode);
    //释放
    CFRelease(observer);
}
@end
  • 打印输出
2018-07-31 22:32:29.778493+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeTimers
2018-07-31 22:32:29.780044+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeSources
2018-07-31 22:32:29.780857+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeTimers
2018-07-31 22:32:29.783191+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeSources
2018-07-31 22:32:29.783808+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeTimers
2018-07-31 22:32:29.784232+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeSources
2018-07-31 22:32:29.785235+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeTimers
2018-07-31 22:32:29.785388+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeSources
2018-07-31 22:32:29.785558+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeTimers
2018-07-31 22:32:29.786129+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeSources
2018-07-31 22:32:29.786779+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeTimers
2018-07-31 22:32:29.786998+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeSources
2018-07-31 22:32:29.789340+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeTimers
2018-07-31 22:32:29.790210+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeSources
2018-07-31 22:32:29.792530+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeTimers
2018-07-31 22:32:29.793507+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeSources
2018-07-31 22:32:29.798424+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeTimers
2018-07-31 22:32:29.798630+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeSources
2018-07-31 22:32:29.800387+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeTimers
2018-07-31 22:32:29.802476+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeSources
2018-07-31 22:32:29.802757+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeWaiting
2018-07-31 22:32:29.805617+0800 01-RunLoop[5232:384864] kCFRunLoopAfterWaiting
2018-07-31 22:32:29.805905+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeTimers
2018-07-31 22:32:29.806267+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeSources
2018-07-31 22:32:29.806377+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeWaiting
2018-07-31 22:32:29.844311+0800 01-RunLoop[5232:384864] kCFRunLoopAfterWaiting
2018-07-31 22:32:29.845274+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeTimers
2018-07-31 22:32:29.845789+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeSources
2018-07-31 22:32:29.846403+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeWaiting
2018-07-31 22:32:29.925660+0800 01-RunLoop[5232:384864] kCFRunLoopAfterWaiting
2018-07-31 22:32:29.926847+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeTimers
2018-07-31 22:32:29.928050+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeSources
2018-07-31 22:32:29.928671+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeWaiting
2018-07-31 22:32:30.041824+0800 01-RunLoop[5232:384864] kCFRunLoopAfterWaiting
2018-07-31 22:32:30.042216+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeTimers
2018-07-31 22:32:30.042762+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeSources
2018-07-31 22:32:30.042918+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeWaiting
2018-07-31 22:32:30.178113+0800 01-RunLoop[5232:384864] kCFRunLoopAfterWaiting
2018-07-31 22:32:30.219570+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeTimers
2018-07-31 22:32:30.219786+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeSources
2018-07-31 22:32:30.220533+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeWaiting
2018-07-31 22:32:30.274901+0800 01-RunLoop[5232:384864] kCFRunLoopAfterWaiting
2018-07-31 22:32:30.277101+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeTimers
2018-07-31 22:32:30.277269+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeSources
2018-07-31 22:32:30.277508+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeWaiting
2018-07-31 22:32:30.767515+0800 01-RunLoop[5232:384864] kCFRunLoopAfterWaiting
2018-07-31 22:32:30.767774+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeTimers
2018-07-31 22:32:30.767892+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeSources
2018-07-31 22:32:30.767997+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeWaiting
2018-07-31 22:32:31.457565+0800 01-RunLoop[5232:384864] kCFRunLoopAfterWaiting
2018-07-31 22:32:31.458090+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeTimers
2018-07-31 22:32:31.458287+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeSources
2018-07-31 22:32:31.458479+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeWaiting
2018-07-31 22:33:00.001934+0800 01-RunLoop[5232:384864] kCFRunLoopAfterWaiting
2018-07-31 22:33:00.004481+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeTimers
2018-07-31 22:33:00.005199+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeSources
2018-07-31 22:33:00.006257+0800 01-RunLoop[5232:384864] kCFRunLoopBeforeWaiting

2、RunLoop Mode切换

  • 测试代码
#import "ViewController.h"

@interface ViewController ()

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    [self observerFun_block];
}

/**
 observer block回调
 */
- (void)observerFun_block {
    // 创建Observer
    CFRunLoopObserverRef observer = CFRunLoopObserverCreateWithHandler(kCFAllocatorDefault, kCFRunLoopAllActivities, YES, 0, ^(CFRunLoopObserverRef observer, CFRunLoopActivity activity) {
        switch (activity) {
            case kCFRunLoopEntry: {
                CFRunLoopMode mode = CFRunLoopCopyCurrentMode(CFRunLoopGetCurrent());
                NSLog(@"kCFRunLoopEntry - %@", mode);
                CFRelease(mode);
                break;
            }
                
            case kCFRunLoopExit: {
                CFRunLoopMode mode = CFRunLoopCopyCurrentMode(CFRunLoopGetCurrent());
                NSLog(@"kCFRunLoopExit - %@", mode);
                CFRelease(mode);
                break;
            }
                
            default:
                break;
        }
    });
    // 添加Observer到RunLoop中
    CFRunLoopAddObserver(CFRunLoopGetMain(), observer, kCFRunLoopCommonModes);
    // 释放
    CFRelease(observer);
}

@end
  • 打印输出
2018-07-31 22:35:18.153490+0800 01-RunLoop[5262:386889] kCFRunLoopExit - kCFRunLoopDefaultMode
2018-07-31 22:35:18.153723+0800 01-RunLoop[5262:386889] kCFRunLoopEntry - UITrackingRunLoopMode
2018-07-31 22:35:25.399625+0800 01-RunLoop[5262:386889] kCFRunLoopExit - UITrackingRunLoopMode
2018-07-31 22:35:25.399830+0800 01-RunLoop[5262:386889] kCFRunLoopEntry - kCFRunLoopDefaultMode
  • 当滑动UIScrollView时，Mode退出kCFRunLoopDefaultMode，进入UITrackingRunLoopMode
  • 当UIScrollView滑动停止时，Mode退出UITrackingRunLoopMode，进入kCFRunLoopDefaultMode

三、RunLoop运行逻辑

RunLoop会被Port、custom、performSelector：onThread：、Timer唤醒
RunLoop会处理handlePort、customSrc、mySelector、timerFired这些任务

RunLoop_第2张图片
RunLoop运行逻辑.png

1、RunLoop循环过程

  • 1、通知Observers：进入Loop
  • 2、通知Observers：即将处理Timers
  • 3、通知Observers：即将处理Sources
  • 4、处理Blocks
  • 5、处理Source0（可能会再次处理Blocks）
  • 6、如果存在Source1，就跳转到第8步
  • 7、通知Observers：开始休眠（等待消息唤醒）
  • 8、通知Observers：结束休眠（被某个消息唤醒）
    • 处理Timer
    • 处理GCD Async To Main Queue
  • 9、处理Blocks
  • 10、根据前面的执行结果，决定如何操作
    • 回到第2步
    • 退出Loop
  • 11、通知Observers：退出Loop
RunLoop_第3张图片
RunLoop运行过程.png

2、源码分析

RunLoop_第4张图片
RunLoop源码.png

1、RunLoop入口

(lldb) bt
* thread #1, queue = 'com.apple.main-thread', stop reason = breakpoint 1.1
  * frame #0: 0x0000000108f8d57f 01-RunLoop`__35-[ViewController observerFun_block]_block_invoke(.block_descriptor=0x0000000108f8f0d0, observer=0x0000604000321540, activity=kCFRunLoopEntry) at ViewController.m:74
    frame #1: 0x000000010992e607 CoreFoundation`__CFRUNLOOP_IS_CALLING_OUT_TO_AN_OBSERVER_CALLBACK_FUNCTION__ + 23
    frame #2: 0x000000010992e55e CoreFoundation`__CFRunLoopDoObservers + 430
    frame #3: 0x00000001099122e7 CoreFoundation`CFRunLoopRunSpecific + 599 //RunLoop入口
    frame #4: 0x000000010f404a73 GraphicsServices`GSEventRunModal + 62
    frame #5: 0x000000010a7890b7 UIKit`UIApplicationMain + 159
    frame #6: 0x0000000108f8d66f 01-RunLoop`main(argc=1, argv=0x00007ffee6c71fe8) at main.m:14
    frame #7: 0x000000010dcf3955 libdyld.dylib`start + 1
    frame #8: 0x000000010dcf3955 libdyld.dylib`start + 1

2、CFRunLoopRunSpecific

SInt32 CFRunLoopRunSpecific(CFRunLoopRef rl, CFStringRef modeName, CFTimeInterval seconds, Boolean returnAfterSourceHandled) {     /* DOES CALLOUT */
    CHECK_FOR_FORK();
    if (__CFRunLoopIsDeallocating(rl)) return kCFRunLoopRunFinished;
    __CFRunLoopLock(rl);
    CFRunLoopModeRef currentMode = __CFRunLoopFindMode(rl, modeName, false);
    if (NULL == currentMode || __CFRunLoopModeIsEmpty(rl, currentMode, rl->_currentMode)) {
    Boolean did = false;
    if (currentMode) __CFRunLoopModeUnlock(currentMode);
    __CFRunLoopUnlock(rl);
    return did ? kCFRunLoopRunHandledSource : kCFRunLoopRunFinished;
    }
    volatile _per_run_data *previousPerRun = __CFRunLoopPushPerRunData(rl);
    CFRunLoopModeRef previousMode = rl->_currentMode;
    rl->_currentMode = currentMode;
    int32_t result = kCFRunLoopRunFinished;

#pragma mark - 通知Observer Entry
    if (currentMode->_observerMask & kCFRunLoopEntry ) __CFRunLoopDoObservers(rl, currentMode, kCFRunLoopEntry);
#pragma mark - 运行RunLoop
    result = __CFRunLoopRun(rl, currentMode, seconds, returnAfterSourceHandled, previousMode);
#pragma mark - 通知Observers Exit
    if (currentMode->_observerMask & kCFRunLoopExit ) __CFRunLoopDoObservers(rl, currentMode, kCFRunLoopExit);

        __CFRunLoopModeUnlock(currentMode);
        __CFRunLoopPopPerRunData(rl, previousPerRun);
    rl->_currentMode = previousMode;
    __CFRunLoopUnlock(rl);
    return result;
}

3、__CFRunLoopRun运行过程

static int32_t __CFRunLoopRun(CFRunLoopRef rl, CFRunLoopModeRef rlm, CFTimeInterval seconds, Boolean stopAfterHandle, CFRunLoopModeRef previousMode) {
    uint64_t startTSR = mach_absolute_time();

    if (__CFRunLoopIsStopped(rl)) {
        __CFRunLoopUnsetStopped(rl);
    return kCFRunLoopRunStopped;
    } else if (rlm->_stopped) {
    rlm->_stopped = false;
    return kCFRunLoopRunStopped;
    }
    
    mach_port_name_t dispatchPort = MACH_PORT_NULL;
    Boolean libdispatchQSafe = pthread_main_np() && ((HANDLE_DISPATCH_ON_BASE_INVOCATION_ONLY && NULL == previousMode) || (!HANDLE_DISPATCH_ON_BASE_INVOCATION_ONLY && 0 == _CFGetTSD(__CFTSDKeyIsInGCDMainQ)));
    if (libdispatchQSafe && (CFRunLoopGetMain() == rl) && CFSetContainsValue(rl->_commonModes, rlm->_name)) dispatchPort = _dispatch_get_main_queue_port_4CF();
    
#if USE_DISPATCH_SOURCE_FOR_TIMERS
    mach_port_name_t modeQueuePort = MACH_PORT_NULL;
    if (rlm->_queue) {
        modeQueuePort = _dispatch_runloop_root_queue_get_port_4CF(rlm->_queue);
        if (!modeQueuePort) {
            CRASH("Unable to get port for run loop mode queue (%d)", -1);
        }
    }
#endif
    
    dispatch_source_t timeout_timer = NULL;
    struct __timeout_context *timeout_context = (struct __timeout_context *)malloc(sizeof(*timeout_context));
    if (seconds <= 0.0) { // instant timeout
        seconds = 0.0;
        timeout_context->termTSR = 0ULL;
    } else if (seconds <= TIMER_INTERVAL_LIMIT) {
    dispatch_queue_t queue = pthread_main_np() ? __CFDispatchQueueGetGenericMatchingMain() : __CFDispatchQueueGetGenericBackground();
    timeout_timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
        dispatch_retain(timeout_timer);
    timeout_context->ds = timeout_timer;
    timeout_context->rl = (CFRunLoopRef)CFRetain(rl);
    timeout_context->termTSR = startTSR + __CFTimeIntervalToTSR(seconds);
    dispatch_set_context(timeout_timer, timeout_context); // source gets ownership of context
    dispatch_source_set_event_handler_f(timeout_timer, __CFRunLoopTimeout);
        dispatch_source_set_cancel_handler_f(timeout_timer, __CFRunLoopTimeoutCancel);
        uint64_t ns_at = (uint64_t)((__CFTSRToTimeInterval(startTSR) + seconds) * 1000000000ULL);
        dispatch_source_set_timer(timeout_timer, dispatch_time(1, ns_at), DISPATCH_TIME_FOREVER, 1000ULL);
        dispatch_resume(timeout_timer);
    } else { // infinite timeout
        seconds = 9999999999.0;
        timeout_context->termTSR = UINT64_MAX;
    }

    Boolean didDispatchPortLastTime = true;
    int32_t retVal = 0;
    do {
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI
        voucher_mach_msg_state_t voucherState = VOUCHER_MACH_MSG_STATE_UNCHANGED;
        voucher_t voucherCopy = NULL;
#endif
        uint8_t msg_buffer[3 * 1024];
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI
        mach_msg_header_t *msg = NULL;
        mach_port_t livePort = MACH_PORT_NULL;
#elif DEPLOYMENT_TARGET_WINDOWS
        HANDLE livePort = NULL;
        Boolean windowsMessageReceived = false;
#endif
    __CFPortSet waitSet = rlm->_portSet;

        __CFRunLoopUnsetIgnoreWakeUps(rl);

#pragma mark - kCFRunLoopBeforeTimers   即将处理Timers
        if (rlm->_observerMask & kCFRunLoopBeforeTimers) __CFRunLoopDoObservers(rl, rlm, kCFRunLoopBeforeTimers);
#pragma mark - kCFRunLoopBeforeSources  即将处理Sources
        if (rlm->_observerMask & kCFRunLoopBeforeSources) __CFRunLoopDoObservers(rl, rlm, kCFRunLoopBeforeSources);
#pragma mark - __CFRunLoopDoBlocks  处理Block
    __CFRunLoopDoBlocks(rl, rlm);
#pragma mark - __CFRunLoopDoSources0  处理BlockSources0
        Boolean sourceHandledThisLoop = __CFRunLoopDoSources0(rl, rlm, stopAfterHandle);
        if (sourceHandledThisLoop) {
#pragma mark - __CFRunLoopDoBlocks  处理Block
            __CFRunLoopDoBlocks(rl, rlm);
    }

        Boolean poll = sourceHandledThisLoop || (0ULL == timeout_context->termTSR);

        if (MACH_PORT_NULL != dispatchPort && !didDispatchPortLastTime) {
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI
            msg = (mach_msg_header_t *)msg_buffer;
#pragma mark - 判断有无Sources1
            if (__CFRunLoopServiceMachPort(dispatchPort, &msg, sizeof(msg_buffer), &livePort, 0, &voucherState, NULL)) {
#pragma mark - 如果有Sources1，跳转到handle_msg
                goto handle_msg;
            }
#elif DEPLOYMENT_TARGET_WINDOWS
            if (__CFRunLoopWaitForMultipleObjects(NULL, &dispatchPort, 0, 0, &livePort, NULL)) {
                goto handle_msg;
            }
#endif
        }

        didDispatchPortLastTime = false;
#pragma mark - kCFRunLoopBeforeWaiting  即将进入休眠
    if (!poll && (rlm->_observerMask & kCFRunLoopBeforeWaiting)) __CFRunLoopDoObservers(rl, rlm, kCFRunLoopBeforeWaiting);
    __CFRunLoopSetSleeping(rl);
    // do not do any user callouts after this point (after notifying of sleeping)

        // Must push the local-to-this-activation ports in on every loop
        // iteration, as this mode could be run re-entrantly and we don't
        // want these ports to get serviced.

        __CFPortSetInsert(dispatchPort, waitSet);
        
    __CFRunLoopModeUnlock(rlm);
    __CFRunLoopUnlock(rl);

        CFAbsoluteTime sleepStart = poll ? 0.0 : CFAbsoluteTimeGetCurrent();

#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI
#if USE_DISPATCH_SOURCE_FOR_TIMERS
        do {
            if (kCFUseCollectableAllocator) {
                // objc_clear_stack(0);
                // 
                memset(msg_buffer, 0, sizeof(msg_buffer));
            }
            msg = (mach_msg_header_t *)msg_buffer;
#pragma mark - 等待别的消息唤醒当前线程
            __CFRunLoopServiceMachPort(waitSet, &msg, sizeof(msg_buffer), &livePort, poll ? 0 : TIMEOUT_INFINITY, &voucherState, &voucherCopy);
            
            if (modeQueuePort != MACH_PORT_NULL && livePort == modeQueuePort) {
                // Drain the internal queue. If one of the callout blocks sets the timerFired flag, break out and service the timer.
                while (_dispatch_runloop_root_queue_perform_4CF(rlm->_queue));
                if (rlm->_timerFired) {
                    // Leave livePort as the queue port, and service timers below
                    rlm->_timerFired = false;
                    break;
                } else {
                    if (msg && msg != (mach_msg_header_t *)msg_buffer) free(msg);
                }
            } else {
                // Go ahead and leave the inner loop.
                break;
            }
        } while (1);
#else
        if (kCFUseCollectableAllocator) {
            // objc_clear_stack(0);
            // 
            memset(msg_buffer, 0, sizeof(msg_buffer));
        }
        msg = (mach_msg_header_t *)msg_buffer;
        __CFRunLoopServiceMachPort(waitSet, &msg, sizeof(msg_buffer), &livePort, poll ? 0 : TIMEOUT_INFINITY, &voucherState, &voucherCopy);
#endif
        
        
#elif DEPLOYMENT_TARGET_WINDOWS
        // Here, use the app-supplied message queue mask. They will set this if they are interested in having this run loop receive windows messages.
        __CFRunLoopWaitForMultipleObjects(waitSet, NULL, poll ? 0 : TIMEOUT_INFINITY, rlm->_msgQMask, &livePort, &windowsMessageReceived);
#endif
        
        __CFRunLoopLock(rl);
        __CFRunLoopModeLock(rlm);

        rl->_sleepTime += (poll ? 0.0 : (CFAbsoluteTimeGetCurrent() - sleepStart));

        // Must remove the local-to-this-activation ports in on every loop
        // iteration, as this mode could be run re-entrantly and we don't
        // want these ports to get serviced. Also, we don't want them left
        // in there if this function returns.

        __CFPortSetRemove(dispatchPort, waitSet);
        
        __CFRunLoopSetIgnoreWakeUps(rl);

        // user callouts now OK again
    __CFRunLoopUnsetSleeping(rl);
#pragma mark - kCFRunLoopAfterWaiting  结束休眠，即将被唤醒
    if (!poll && (rlm->_observerMask & kCFRunLoopAfterWaiting)) __CFRunLoopDoObservers(rl, rlm, kCFRunLoopAfterWaiting);


#pragma mark - handle_msg
        handle_msg:;
        __CFRunLoopSetIgnoreWakeUps(rl);

#if DEPLOYMENT_TARGET_WINDOWS
        if (windowsMessageReceived) {
            // These Win32 APIs cause a callout, so make sure we're unlocked first and relocked after
            __CFRunLoopModeUnlock(rlm);
        __CFRunLoopUnlock(rl);

            if (rlm->_msgPump) {
                rlm->_msgPump();
            } else {
                MSG msg;
                if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE | PM_NOYIELD)) {
                    TranslateMessage(&msg);
                    DispatchMessage(&msg);
                }
            }
            
            __CFRunLoopLock(rl);
        __CFRunLoopModeLock(rlm);
        sourceHandledThisLoop = true;
            
            // To prevent starvation of sources other than the message queue, we check again to see if any other sources need to be serviced
            // Use 0 for the mask so windows messages are ignored this time. Also use 0 for the timeout, because we're just checking to see if the things are signalled right now -- we will wait on them again later.
            // NOTE: Ignore the dispatch source (it's not in the wait set anymore) and also don't run the observers here since we are polling.
            __CFRunLoopSetSleeping(rl);
            __CFRunLoopModeUnlock(rlm);
            __CFRunLoopUnlock(rl);
            
            __CFRunLoopWaitForMultipleObjects(waitSet, NULL, 0, 0, &livePort, NULL);
            
            __CFRunLoopLock(rl);
            __CFRunLoopModeLock(rlm);            
            __CFRunLoopUnsetSleeping(rl);
            // If we have a new live port then it will be handled below as normal
        }
        
        
#endif
        if (MACH_PORT_NULL == livePort) {
            CFRUNLOOP_WAKEUP_FOR_NOTHING();
            // handle nothing
        } else if (livePort == rl->_wakeUpPort) {
            CFRUNLOOP_WAKEUP_FOR_WAKEUP();
            // do nothing on Mac OS
#if DEPLOYMENT_TARGET_WINDOWS
            // Always reset the wake up port, or risk spinning forever
            ResetEvent(rl->_wakeUpPort);
#endif
        }
#if USE_DISPATCH_SOURCE_FOR_TIMERS
        else if (modeQueuePort != MACH_PORT_NULL && livePort == modeQueuePort) {
            CFRUNLOOP_WAKEUP_FOR_TIMER();
#pragma mark - 被Timer唤醒
            if (!__CFRunLoopDoTimers(rl, rlm, mach_absolute_time())) {
                // Re-arm the next timer, because we apparently fired early
                __CFArmNextTimerInMode(rlm, rl);
            }
        }
#endif
#if USE_MK_TIMER_TOO
        else if (rlm->_timerPort != MACH_PORT_NULL && livePort == rlm->_timerPort) {
            CFRUNLOOP_WAKEUP_FOR_TIMER();
            // On Windows, we have observed an issue where the timer port is set before the time which we requested it to be set. For example, we set the fire time to be TSR 167646765860, but it is actually observed firing at TSR 167646764145, which is 1715 ticks early. The result is that, when __CFRunLoopDoTimers checks to see if any of the run loop timers should be firing, it appears to be 'too early' for the next timer, and no timers are handled.
            // In this case, the timer port has been automatically reset (since it was returned from MsgWaitForMultipleObjectsEx), and if we do not re-arm it, then no timers will ever be serviced again unless something adjusts the timer list (e.g. adding or removing timers). The fix for the issue is to reset the timer here if CFRunLoopDoTimers did not handle a timer itself. 9308754
#pragma mark - 被Timer唤醒
            if (!__CFRunLoopDoTimers(rl, rlm, mach_absolute_time())) {
                // Re-arm the next timer
                __CFArmNextTimerInMode(rlm, rl);
            }
        }
#endif
#pragma mark - 被GCD唤醒
        else if (livePort == dispatchPort) {
            CFRUNLOOP_WAKEUP_FOR_DISPATCH();
            __CFRunLoopModeUnlock(rlm);
            __CFRunLoopUnlock(rl);
            _CFSetTSD(__CFTSDKeyIsInGCDMainQ, (void *)6, NULL);
#if DEPLOYMENT_TARGET_WINDOWS
            void *msg = 0;
#endif
#pragma mark - 被GCD唤醒，调用__CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__
            __CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__(msg);
            _CFSetTSD(__CFTSDKeyIsInGCDMainQ, (void *)0, NULL);
            __CFRunLoopLock(rl);
            __CFRunLoopModeLock(rlm);
            sourceHandledThisLoop = true;
            didDispatchPortLastTime = true;
        } else {
#pragma mark - 被Source1唤醒
            CFRUNLOOP_WAKEUP_FOR_SOURCE();
            
            // If we received a voucher from this mach_msg, then put a copy of the new voucher into TSD. CFMachPortBoost will look in the TSD for the voucher. By using the value in the TSD we tie the CFMachPortBoost to this received mach_msg explicitly without a chance for anything in between the two pieces of code to set the voucher again.
            voucher_t previousVoucher = _CFSetTSD(__CFTSDKeyMachMessageHasVoucher, (void *)voucherCopy, os_release);

            // Despite the name, this works for windows handles as well
            CFRunLoopSourceRef rls = __CFRunLoopModeFindSourceForMachPort(rl, rlm, livePort);
            if (rls) {
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI
        mach_msg_header_t *reply = NULL;
        sourceHandledThisLoop = __CFRunLoopDoSource1(rl, rlm, rls, msg, msg->msgh_size, &reply) || sourceHandledThisLoop;
        if (NULL != reply) {
            (void)mach_msg(reply, MACH_SEND_MSG, reply->msgh_size, 0, MACH_PORT_NULL, 0, MACH_PORT_NULL);
            CFAllocatorDeallocate(kCFAllocatorSystemDefault, reply);
        }
#elif DEPLOYMENT_TARGET_WINDOWS
                sourceHandledThisLoop = __CFRunLoopDoSource1(rl, rlm, rls) || sourceHandledThisLoop;
#endif
        }
            
            // Restore the previous voucher
            _CFSetTSD(__CFTSDKeyMachMessageHasVoucher, previousVoucher, os_release);
            
        } 
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI
        if (msg && msg != (mach_msg_header_t *)msg_buffer) free(msg);
#endif

#pragma mark - 处理Blocks
    __CFRunLoopDoBlocks(rl, rlm);
        
#pragma mark - 计算retVal结果
    if (sourceHandledThisLoop && stopAfterHandle) {
        retVal = kCFRunLoopRunHandledSource;
        } else if (timeout_context->termTSR < mach_absolute_time()) {
            retVal = kCFRunLoopRunTimedOut;
    } else if (__CFRunLoopIsStopped(rl)) {
            __CFRunLoopUnsetStopped(rl);
        retVal = kCFRunLoopRunStopped;
    } else if (rlm->_stopped) {
        rlm->_stopped = false;
        retVal = kCFRunLoopRunStopped;
    } else if (__CFRunLoopModeIsEmpty(rl, rlm, previousMode)) {
        retVal = kCFRunLoopRunFinished;
    }
        
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI
        voucher_mach_msg_revert(voucherState);
        os_release(voucherCopy);
#endif

    } while (0 == retVal);

    if (timeout_timer) {
        dispatch_source_cancel(timeout_timer);
        dispatch_release(timeout_timer);
    } else {
        free(timeout_context);
    }

    return retVal;
}

你可能感兴趣的:(RunLoop)

  • iOS—RunLoop详解 Fttt. iOSRunLoop
    文章目录什么是RunLoop获取runloopRunLoop结构CFRunLoopModeRef五种ModeCFRunLoopSourceRefCFRunLoopTimerRefCFRunLoopObserverRefRunLoop的内部逻辑RunLoop回调RunLoop在实际开发中的应用解决NSTimer在滑动时停止工作的问题线程保活RunLoop启动方法RunLoop关闭方法什么是RunLo
  • 【iOS】RunLoop面试题总结 - 持续更新 cheng_lin0201 OCRunloopiOS底层原理iosobjective-c
    面试题1.RunLoop和线程的关系？答：一个线程对应一个RunLoop主线程默认就有RunLoop子线程的RunLoop以懒加载的形式创建RunLoop存储在一个全局的可变字典里，线程是key，RunLoop是value2.RunLoop的运行模式答：Runloop的运行模式共有5种，RunLoop只会运行在一个模式下，要切换模式，就要暂停当前模式，重写启动一个运行模式3.RunLoop内部逻辑
  • Web 游戏 「梦幻西游」地图 Demo ，纯 Canvas 画 梁同桌
    前言本程序仅仅学习，顺便回忆小学玩的游戏。项目初心为了验证一些对Canvas想法。项目大量运用ES6，无";"写法。cover.gif目录文件介绍职责分类缺点文件imgjxk（剑侠客图片）background（地图图片）jsbaserunloop.js（循环）viewjxk.js（剑侠客）map_one.js（地图）game.jsindex.jsindex.html职责分类js/base/runl
  • - (void)performSelector: onThread: withObject: waitUntilDone: 和 dispatch_async _RG
    -(void)performSelector:(SEL)aSelectoronThread:(NSThread*)thrwithObject:(nullableid)argwaitUntilDone:(BOOL)wait指定默认模式在指定线程上调用接收器的方法，当wait为YES时，会立即调用接收器方法，当wait为NO时，会将操作加入到runloop中排队，当有机会时才执行此操作跟新UI时一般用
  • Runloop理解 今年27
    Runloop:运行循环-死循环我们的应用程序在启动的时候1.开启一条线程!即主线程2.主线程为常驻线程!因为在线程上开启了一个RunloopRunloop作用:1.保证线程不退出2.负责监听所有的事件(触摸\计时器\网络事件)Runloop有5钟模式,一般有1.默认模式NSDefaultRunLoopMode2.UI模式,UITrackingRunLoopMode3.common模式(即占位模式
  • RunLoop 的底层实现 二斤寂寞
    RunLoop的核心是基于machport的，其进入休眠时调用的函数是mach_msg()。为了解释这个逻辑，下面稍微介绍一下OSX/iOS的系统架构。image.png苹果官方将整个系统大致划分为上述4个层次：应用层:包括用户能接触到的图形应用，例如Spotlight、Aqua、SpringBoard等。应用框架层:即开发人员接触到的Cocoa等框架。核心框架层:包括各种核心框架、OpenGL等
  • iOS面试题-RunLoop Peter杰
    1.RunLoop和线程的关系每条线程都有唯一的一个RunLoop对象与之对应的主线程的RunLoop是自动创建并启动，子线程的RunLoop需要手动创建3.RunLoop会在线程结束时销毁线程刚创建时并没有RunLoop对象，RunLoop会在第一次获取它时创建，子线程的RunLoop创建步骤如下：在子线程中调用[NSRunLoopcurrentRunLoop]创建RunLoop对象（懒加载，只
  • oc- Runloop的理解 雨天多久就
    什么是runloop？从字面上理解，是一个运行循环。一般情况下，我们写一个函数，从函数调用开始到函数结束，执行完后，函数的任务就完成了，函数对应的内存都会被系统收回。但是如果我们想函数能够一直执行，该怎么做？这个时候在函数内部写一个死循环就可以了。这样这个函数就永远都在。系统的runloop大致也是这个道理。它就是一个事件循环机制，遇到有处理的事情就处理，没有的话就休眠进行等待唤醒。不同的是，系统
  • iOS 涨薪： Run Loop 面试题 编程怪才_凌雨画
    RunLoop运行循环app程序只有不停地运行,才能不断响应用户的操作RunLoop两大功能:睡眠中，等待消息处理消息从睡眠中->处理消息,需要一个唤醒的过程1、讲讲RunLoop,项目中有用到吗？RunLoop的基本作用：保持程序的持续运行节省CPU的资源，提高程序的性能（没有事情，就请休眠，不要功耗。有事情，就处理）2、RunLoop内部实现逻辑？CoreFoundation中关于RunLoo
  • RunLoop 三 : 使用RunLoop线程保活的封装 小心韩国人
    在RunLoop二:RunLoop在实际中的应用篇幅中我们介绍了runloop在项目中的具体用法,并且创建了一个可以控制生命周期的线程.今天我们就用OC和C语言两种方法封装一个线程保活的工具类:一:使用OC语言封装://监控线程生命周期@interfaceMYThread:NSThread@end@implementationMYThread-(void)dealloc{NSLog(@"%s",_
  • Objective-C学习笔记-回调 土豆吞噬者
    1.OC中有四种方法实现回调，分别是目标-动作对，辅助对象，通知，Block对象2.目标-动作对，是指当某个事件发生时，向指定对象发送指定消息，计时器使用的就是目标-动作对机制，如下代码所示，每隔两秒会执行一次updateLastTime方法，其中NSRunLoop用来保持线程允许并处理事件-(void)updateLastTime:(NSTimer*)t{NSLog(@"timeris%@",t
  • Runtime和Runloop部分理解 yycache
    Runtime01问题：objc在向一个对象发送消息时，发生了什么？解答：根据对象的isa指针找到类对象id，在查询类对象里面的methodLists方法函数列表，如果没有在好到，在沿着superClass,寻找父类，再在父类methodLists方法列表里面查询，最终找到SEL,根据id和SEL确认IMP（指针函数）,在发送消息；03问题：什么时候会报unrecognizedselector错误
  • 2020-11-10 GDCoder
    runloop笔记参考：https://www.jianshu.com/p/d260d18dd551
  • iOS-多线程(四)-GCD定时器 xxxxxxxx_123
    日常的开发中，我们经常会用到计时器。在iOS中，有三种计时器，NSTimer、CADisplayLink、dispatch_source，这三种定时器都是各有优劣。NSTimerNSTimer是使用的比较多的一种，但是精度不够，其原因如下：NSTimer加在mainrunloop中，模式是NSDefaultRunLoopMode，main负责所有主线程事务，例如UI界面的操作、复杂的运算等等，这样
  • RunLoop 与线程的关系 二斤寂寞
    苹果不允许直接创建RunLoop，它只提供了两个自动获取的函数：CFRunLoopGetMain()和CFRunLoopGetCurrent()。这两个函数内部的逻辑大概是下面这样:///全局的Dictionary，key是pthread_t，value是CFRunLoopRefstaticCFMutableDictionaryRefloopsDic;///访问loopsDic时的锁staticC
  • RunLoop补充知识 测试开发雨辰
    RunLoop知识合集如下图：RunLoop.pngCFRunLoop简化后的代码分析staticint32_t__CFRunLoopRun(CFRunLoopRefrl,CFRunLoopModeRefrlm,CFTimeIntervalseconds,BooleanstopAfterHandle,CFRunLoopModeRefpreviousMode){BooleandidDispatchP
  • 多种方法解决NSTimer不释放问题 king_jensen
    相信iOS开发过程中,肯定大多数人都知道Timer的释放不掉问题,但是否认真考虑过其中释放不掉的原因?self.timer=[NSTimerscheduledTimerWithTimeInterval:1target:selfselector:@selector(timerRun:)userInfo:nilrepeats:YES];不释放原因Timer添加到Runloop的时候，会被Runloop
  • iOS-无限时后台 linbj
    创建一个计时器放到NSRunLoop中修改UIBackgroundTaskIdentifier状态@property(nonatomic,strong)NSTimer*timer;@property(nonatomic,assign)UIBackgroundTaskIdentifierbgTask;//用于申请后台时间-(void)applicationDidEnterBackground:(UI
  • iOS-浅谈RunLoop 梦蕊dream
    前言：本文简述RunLoop相关内容，如有错误请留言指正。Q：什么是RunLoop？运行循环，在程序运行过程中循环做一些事情Q：RunLoop的应用？定时器（Timer）、PerformSelectorGCDAsyncMainQueue事件响应、手势识别、界面刷新网络请求AutoreleasePoolQ：RunLoop什么作用？保持程序的持续运行处理App中的各种事件（比如触摸事件、定时器事件等）
  • 小米百度bigo 滴滴 快手等iOS 面试题2021年 文博同学
    面试过程在疫情期间都是远程面试，下边先介绍一下疫情期间面试的一些公司的面试情况。同时拿到了其中几家的offer。下边介绍的面试题只还原了其中印象比较深的部分，会存在不足的情况，并不代表面试的全部。小米一面介绍有哪些设计原则，并让比较详细的说了其中开闭原则在项目中的应用。介绍设计模式，然后其中主要问了我抽象工厂和适配器两种模式。介绍runloop相关的知识和在实际开发中的使用情况要求详细的描述事件响
  • RunLoop总结：RunLoop的应用场景（五） 咖啡绿茶1991
    今天要介绍的RunLoop应用场景感觉很酷炫，我们可能不常用到，但是对于做Crash收集的SDK可能会用得比较频繁吧。相比关于RunLoop可以让应用起死回生，大家都听说过，可是怎么实现呢？今天我就来实际试验一下。资料sunnyxx线下分享RunLoop(这是一份关于线下分享与讨论RunLoop的视频，备用地址：https://pan.baidu.com/s/1pLm4Vf9）漫谈iOSCrash
  • iOS RunLoop底层原理分析 冼同学
    准备工作coreFoundationswift-corelibs-foundation1.什么是RunLoopRunLoop是一个运行循环，也是一个对象，并且提供了入口函数，进行dowhile循环，保证运行程序不退出。一个程序运行结束的标志性语句是return，在iOS应用的入口main函数中，return并执行了一个UIApplicationMain函数，如下：main函数既然已经return了
  • IOS技能树总结 流星飞鱼
    最近记录一下iOS面试题，只做笔记，方便随时查看，如有不当之处感谢大牛指点。目录如下，持续更新。技能要求UI视图OC语言Runtime内存管理Block多线程RunLoop网络设计模式架构/框架算法第三方面试总结1.技能要求初级：精通Objective-C语言基础精通UIKit等CocoaFramework熟悉网络通信机制以及常用数据传输协议具备主流开源框架的使用经验中级：扎实的编程基础、能够设计
  • runloop和autorelease 高思阳
    有这么一道iOS面试题以下代码有没有什么问题?如果有?如何解决?for(inti=0;i
  • 从事iOS开发7年的面经，送给准备面试的你！ iOS开发之家
    前言：今天和大家分享一下，我从事iOS开发6年的面试心得。大大小小参加过不下30+公司的面试，其中不乏BAT、TMD等一线互联网公司，总结一下，发现大厂招聘都有一个共性。对技术的要求很全面，有些同学认为iOS掌握了基础的UI、网络、内存、多线程等等就够了，其实要想更好的应付iOS的面试，这些是远远不够的。比如对RunTime底层实现机制、RunLoop的用户态到核心态切换逻辑，设计模式、架构以及框
  • IOS开发谈谈对Runtime 和 Runloop的理解 谢千域
    RuntimeRuntime简称运行时，OC就是运行时机制，也就是在运行时候的一些机制，其中最重要的事消息机制。作用消息机制原理:对象根据方法编号SEL去映射表查找对应的方法实现方法调用的本质就是让对象发送消息objc_msgSend，只用对象才能发送消息，因此以objc开头。使用消息机制前提，必须导入#import使用场景交换方法动态添加方法给分类添加属性字典转模型：RuntimeRunLoop
  • iOS RunLoop Nothing_xy
    什么是RunLoop？可以理解为字面意思：Run表示运行，Loop表示循环。结合在一起就是运行的循环的意思。哈哈，我更愿意翻译为『跑圈』。直观理解就像是不停的跑圈RunLoop实际上是一个对象，这个对象在循环中用来处理程序运行过程中出现的各种事件（比如说触摸事件、UI刷新事件、定时器事件、Selector事件），从而保持程序的持续运行；而且在没有事件处理的时候，会进入睡眠模式，从而节省CPU资源，
  • iOS知识点总结（6）- RunTime RunLoop Block 飞哥漂流记
    RunTime参考：https://www.jianshu.com/p/6ebda3cd8052RunLoop参考：https://www.jianshu.com/p/de752066d0ad什么是Block，Block的本质是什么？block本质上也是一个OC对象，它内部也有个isa指针block是封装了函数调用以及函数调用环境的OC对象block是封装函数及其上下文的OC对象intage=10
  • 以+ scheduledTimerWithTimeInterval...的方式触发的timer，在滑动页面上的列表时，timer会暂定回调，为什么？如何解决？ 华语新空
    以+scheduledTimerWithTimeInterval...的方式触发的timer，在滑动页面上的列表时，timer会暂定回调，为什么？如何解决？RunLoop只能运行在一种mode下，如果要换mode，当前的loop也需要停下重启成新的。利用这个机制，ScrollView滚动过程中NSDefaultRunLoopMode（kCFRunLoopDefaultMode）的mode会切换到U
  • RunLoop 大写的空气
    基本作用保持程序的持续运行(比如主运行循环)处理App中的各种事件（比如触摸事件、定时器事件、Selector事件）节省CPU资源，提高程序性能：该做事时做事，该休息时休息RunLoop与线程每条线程都有唯一的一个与之对应的RunLoop对象主线程的RunLoop已经自动创建好了，子线程的RunLoop需要主动创建RunLoop在第一次获取时创建，在线程结束时销毁一个RunLoop包含若干个Mod
  • 解读Servlet原理篇二---GenericServlet与HttpServlet 周凡杨 javaHttpServlet源理GenericService源码
    在上一篇《解读Servlet原理篇一》中提到，要实现javax.servlet.Servlet接口（即写自己的Servlet应用），你可以写一个继承自javax.servlet.GenericServletr的generic Servlet ，也可以写一个继承自java.servlet.http.HttpServlet的HTTP Servlet（这就是为什么我们自定义的Servlet通常是exte
  • MySQL性能优化 bijian1013 数据库mysql
            性能优化是通过某些有效的方法来提高MySQL的运行速度，减少占用的磁盘空间。性能优化包含很多方面，例如优化查询速度，优化更新速度和优化MySQL服务器等。本文介绍方法的主要有：         a.优化查询         b.优化数据库结构  
  • ThreadPool定时重试 dai_lm javaThreadPoolthreadtimertimertask
    项目需要当某事件触发时，执行http请求任务，失败时需要有重试机制，并根据失败次数的增加，重试间隔也相应增加，任务可能并发。 由于是耗时任务，首先考虑的就是用线程来实现，并且为了节约资源，因而选择线程池。 为了解决不定间隔的重试，选择Timer和TimerTask来完成 package threadpool; public class ThreadPoolTest {
  • Oracle 查看数据库的连接情况 周凡杨 sqloracle 连接
    首先要说的是，不同版本数据库提供的系统表会有不同，你可以根据数据字典查看该版本数据库所提供的表。 select * from dict where table_name like '%SESSION%'; 就可以查出一些表，然后根据这些表就可以获得会话信息 select sid,serial#,status,username,schemaname,osuser,terminal,ma
  • 类的继承 朱辉辉33 java
    类的继承可以提高代码的重用行，减少冗余代码；还能提高代码的扩展性。Java继承的关键字是extends 格式:public class 类名（子类）extends 类名（父类）{ } 子类可以继承到父类所有的属性和普通方法，但不能继承构造方法。且子类可以直接使用父类的public和 protected属性，但要使用private属性仍需通过调用。 子类的方法可以重写，但必须和父类的返回值类
  • android 悬浮窗特效 肆无忌惮_ android
    最近在开发项目的时候需要做一个悬浮层的动画，类似于支付宝掉钱动画。但是区别在于，需求是浮出一个窗口，之后边缩放边位移至屏幕右下角标签处。效果图如下：   一开始考虑用自定义View来做。后来发现开线程让其移动很卡，ListView+动画也没法精确定位到目标点。   后来想利用Dialog的dismiss动画来完成。   自定义一个Dialog后，在styl
  • hadoop伪分布式搭建 林鹤霄 hadoop
    要修改4个文件    1: vim hadoop-env.sh  第九行    2: vim core-site.xml            <configuration>     &n
  • gdb调试命令 aigo gdb
    原文：http://blog.csdn.net/hanchaoman/article/details/5517362   一、GDB常用命令简介   r run 运行.程序还没有运行前使用 c             cuntinue 
  • Socket编程的HelloWorld实例 alleni123 socket
    public class Client { public static void main(String[] args) { Client c=new Client(); c.receiveMessage(); } public void receiveMessage(){ Socket s=null; BufferedRea
  • 线程同步和异步 百合不是茶 线程同步异步
    多线程和同步 : 如进程、线程同步，可理解为进程或线程A和B一块配合，A执行到一定程度时要依靠B的某个结果，于是停下来，示意B运行；B依言执行，再将结果给A；A再继续操作。 所谓同步，就是在发出一个功能调用时，在没有得到结果之前，该调用就不返回，同时其它线程也不能调用这个方法   多线程和异步:多线程可以做不同的事情,涉及到线程通知     &
  • JSP中文乱码分析 bijian1013 javajsp中文乱码
            在JSP的开发过程中，经常出现中文乱码的问题。         首先了解一下Java中文问题的由来：         Java的内核和class文件是基于unicode的，这使Java程序具有良好的跨平台性，但也带来了一些中文乱码问题的麻烦。原因主要有两方面，
  • js实现页面跳转重定向的几种方式 bijian1013 JavaScript重定向
            js实现页面跳转重定向有如下几种方式： 一.window.location.href <script language="javascript"type="text/javascript"> window.location.href="http://www.baidu.c
  • 【Struts2三】Struts2 Action转发类型 bit1129 struts2
     在【Struts2一】 Struts Hello World http://bit1129.iteye.com/blog/2109365中配置了一个简单的Action，配置如下   <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configurat
  • 【HBase十一】Java API操作HBase bit1129 hbase
    Admin类的主要方法注释：   1. 创建表 /** * Creates a new table. Synchronous operation. * * @param desc table descriptor for table * @throws IllegalArgumentException if the table name is res
  • nginx gzip ronin47 nginx gzip
    Nginx GZip 压缩 Nginx GZip 模块文档详见：http://wiki.nginx.org/HttpGzipModule 常用配置片段如下： gzip on; gzip_comp_level 2; # 压缩比例，比例越大，压缩时间越长。默认是1 gzip_types text/css text/javascript; # 哪些文件可以被压缩 gzip_disable &q
  • java-7.微软亚院之编程判断俩个链表是否相交 给出俩个单向链表的头指针，比如 h1 ， h2 ，判断这俩个链表是否相交 bylijinnan java
    public class LinkListTest { /** * we deal with two main missions: * * A. * 1.we create two joined-List(both have no loop) * 2.whether list1 and list2 join * 3.print the join
  • Spring源码学习-JdbcTemplate batchUpdate批量操作 bylijinnan javaspring
    Spring JdbcTemplate的batch操作最后还是利用了JDBC提供的方法，Spring只是做了一下改造和封装 JDBC的batch操作： String sql = "INSERT INTO CUSTOMER " + "(CUST_ID, NAME, AGE) VALUES (?, ?, ?)";
  • [JWFD开源工作流]大规模拓扑矩阵存储结构最新进展 comsci 工作流
        生成和创建类已经完成,构造一个100万个元素的矩阵模型,存储空间只有11M大,请大家参考我在博客园上面的文档"构造下一代工作流存储结构的尝试",更加相信的设计和代码将陆续推出.........     竞争对手的能力也很强.......,我相信..你们一定能够先于我们推出大规模拓扑扫描和分析系统的....
  • base64编码和url编码 cuityang base64url
    import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.PrintWriter; import java.io.StringWriter; import java.io.UnsupportedEncodingException;
  • web应用集群Session保持 dalan_123 session
    关于使用 memcached 或redis 存储 session ，以及使用 terracotta 服务器共享。建议使用 redis，不仅仅因为它可以将缓存的内容持久化，还因为它支持的单个对象比较大，而且数据类型丰富，不只是缓存 session，还可以做其他用途，一举几得啊。1、使用 filter 方法存储这种方法比较推荐，因为它的服务器使用范围比较多，不仅限于tomcat ，而且实现的原理比较简
  • Yii 框架里数据库操作详解-[增加、查询、更新、删除的方法 'AR模式'] dcj3sjt126com 数据库
        public function getMinLimit () {        $sql = "...";        $result = yii::app()->db->createCo
  • solr StatsComponent（聚合统计） eksliang solr聚合查询solr stats
    StatsComponent 转载请出自出处：http://eksliang.iteye.com/blog/2169134 http://eksliang.iteye.com/ 一、概述        Solr可以利用StatsComponent 实现数据库的聚合统计查询，也就是min、max、avg、count、sum的功能   二、参数
  • 百度一道面试题 greemranqq 位运算百度面试寻找奇数算法bitmap 算法
    那天看朋友提了一个百度面试的题目：怎么找出{1,1,2,3,3,4,4,4,5,5,5,5}  找出出现次数为奇数的数字.   我这里复制的是原话，当然顺序是不一定的，很多拿到题目第一反应就是用map,当然可以解决，但是效率不高。   还有人觉得应该用算法xxx,我是没想到用啥算法好...！   还有觉得应该先排序...   还有觉
  • Spring之在开发中使用SpringJDBC ihuning spring
      在实际开发中使用SpringJDBC有两种方式：   1. 在Dao中添加属性JdbcTemplate并用Spring注入；     JdbcTemplate类被设计成为线程安全的，所以可以在IOC 容器中声明它的单个实例，并将这个实例注入到所有的 DAO 实例中。JdbcTemplate也利用了Java 1.5 的特定(自动装箱，泛型，可变长度
  • JSON API 1.0 核心开发者自述 | 你所不知道的那些技术细节 justjavac json
    2013年5月，Yehuda Katz 完成了JSON API(英文，中文) 技术规范的初稿。事情就发生在 RailsConf 之后，在那次会议上他和 Steve Klabnik 就 JSON 雏形的技术细节相聊甚欢。在沟通单一 Rails 服务器库—— ActiveModel::Serializers 和单一 JavaScript 客户端库——&
  • 网站项目建设流程概述 macroli 工作
    一.概念 网站项目管理就是根据特定的规范、在预算范围内、按时完成的网站开发任务。 二.需求分析 项目立项 　　我们接到客户的业务咨询，经过双方不断的接洽和了解，并通过基本的可行性讨论够，初步达成制作协议，这时就需要将项目立项。较好的做法是成立一个专门的项目小组，小组成员包括：项目经理，网页设计，程序员，测试员，编辑/文档等必须人员。项目实行项目经理制。 客户的需求说明书 　　第一步是需
  • AngularJs 三目运算 表达式判断 qiaolevip 每天进步一点点学习永无止境众观千象AngularJS
    事件回顾：由于需要修改同一个模板，里面包含2个不同的内容，第一个里面使用的时间差和第二个里面名称不一样，其他过滤器，内容都大同小异。希望杜绝If这样比较傻的来判断if-show or not，继续追究其源码。 var b = "{{", a = "}}"; this.startSymbol = function(a) {
  • Spark算子：统计RDD分区中的元素及数量 superlxw1234 sparkspark算子Spark RDD分区元素
    关键字：Spark算子、Spark RDD分区、Spark RDD分区元素数量     Spark RDD是被分区的，在生成RDD时候，一般可以指定分区的数量，如果不指定分区数量，当RDD从集合创建时候，则默认为该程序所分配到的资源的CPU核数，如果是从HDFS文件创建，默认为文件的Block数。   可以利用RDD的mapPartitionsWithInd
  • Spring 3.2.x将于2016年12月31日停止支持 wiselyman Spring 3
                  Spring 团队公布在2016年12月31日停止对Spring Framework 3.2.x（包含tomcat 6.x）的支持。在此之前spring团队将持续发布3.2.x的维护版本。          请大家及时准备及时升级到Spring
  • fis纯前端解决方案fis-pure zccst JavaScript
    作者：zccst FIS通过插件扩展可以完美的支持模块化的前端开发方案，我们通过FIS的二次封装能力，封装了一个功能完备的纯前端模块化方案pure。 1，fis-pure的安装 $ fis install -g fis-pure $ pure -v 0.1.4 2，下载demo到本地 git clone https://github.com/hefangshi/f
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他