An NSTimer that responds every 3 seconds is added to the program. When the tableview is dragged, the timer may not respond. What should I do?
How does the Runloop respond to user operations, and what is the specific process?
Talk about several states of RunLoop?
What is the mode function of Runloop?
1. Introduction to RunLoop
Run loop, do some things in a loop while the program is running. If there is no Runloop program, it will exit immediately. If there is a Runloop program, it will run all the time and wait for the user's input operation all the time. RunLoop can run itself when needed, and stop and rest when there is no operation. Fully save CPU resources and improve program performance.
2. Basic functions of RunLoop:
To keep the program running continuously , a main thread will be opened as soon as the program starts, and a RunLoop corresponding to the main thread will run as soon as the main thread is started. RunLoop ensures that the main thread will not be destroyed, which also ensures the continuous operation of the program.
Handle various events in the App (such as: touch events, timer events, Selector events, etc.)
Save CPU resources and improve program performance . When the program is running, when nothing is done, RunLoop will tell the CPU that there is nothing to do now, and I am going to rest, then the CPU will release its resources to do other things When there is something to do, RunLoop will immediately get up and do it. Let 's take a brief look at the internal operation principle of RunLoop through a picture in the API.It can be seen from the picture that RunLoop will hand over to the corresponding processor for processing when it receives Input sources or Timer sources during the lap run. When no event message comes in, RunLoop rests. Here is just a brief understanding of this picture. Next, let's learn about the RunLoop object and some of its related classes to gain a deeper understanding of the RunLoop running process.
3. Where to start RunLoop
The Runloop is started in the UIApplicationMain function, and the program will not exit immediately, but will remain running. Therefore, every application must have a runloop. We know that as soon as the main thread is started, it will run a RunLoop corresponding to the main thread, so the RunLoop must be opened in the entry main function of the program.
We find that it returns an int number, then we make some modifications to the main function
int main(int argc, char * argv[]) {
@autoreleasepool {
NSLog(@"开始");
int re = UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class]));
NSLog(@"结束");
return re;
}
}
Running the program, we found that it will only print the start, but not the end, which means that in the UIApplicationMain function, a RunLoop related to the main thread is opened, so that UIApplicationMain will not return and is always running, which ensures the program's run continuously . Let's see the source code of RunLoop
// 用DefaultMode启动
void CFRunLoopRun(void) { /* DOES CALLOUT */
int32_t result;
do {
result = CFRunLoopRunSpecific(CFRunLoopGetCurrent(), kCFRunLoopDefaultMode, 1.0e10, false);
CHECK_FOR_FORK();
} while (kCFRunLoopRunStopped != result && kCFRunLoopRunFinished != result);
}
We found that RunLoop is indeed implemented by judging the value of result while do while. Therefore, we can think of RunLoop as an infinite loop. If there is no RunLoop, the UIApplicationMain function will return directly after execution, and no program will continue to run.
4. RunLoop object
Fundation framework (based on CFRunLoopRef encapsulation) NSRunLoop object
CoreFoundation CFRunLoopRef object
Because the Fundation framework is a layer of OC encapsulation based on CFRunLoopRef, here we mainly study the source code of CFRunLoopRef
How to get the RunLoop object
Foundation
[NSRunLoop currentRunLoop]; // 获得当前线程的RunLoop对象
[NSRunLoop mainRunLoop]; // 获得主线程的RunLoop对象
Core Foundation
CFRunLoopGetCurrent(); // 获得当前线程的RunLoop对象
CFRunLoopGetMain(); // 获得主线程的RunLoop对象
Five. The relationship between RunLoop and threads
Each thread has a unique RunLoop object corresponding to it
RunLoop is stored in a global Dictionary, thread as key, RunLoop as value
The RunLoop of the main thread has been automatically created, and the RunLoop of the child thread needs to be actively created
RunLoop is created when it is first acquired and destroyed when the thread ends
View the above correspondence through the source code
// 拿到当前Runloop 调用_CFRunLoopGet0
CFRunLoopRef CFRunLoopGetCurrent(void) {
CHECK_FOR_FORK();
CFRunLoopRef rl = (CFRunLoopRef)_CFGetTSD(__CFTSDKeyRunLoop);
if (rl) return rl;
return _CFRunLoopGet0(pthread_self());
}
// 查看_CFRunLoopGet0方法内部
CF_EXPORT CFRunLoopRef _CFRunLoopGet0(pthread_t t) {
if (pthread_equal(t, kNilPthreadT)) {
t = pthread_main_thread_np();
}
__CFLock(&loopsLock);
if (!__CFRunLoops) {
__CFUnlock(&loopsLock);
CFMutableDictionaryRef dict = CFDictionaryCreateMutable(kCFAllocatorSystemDefault, 0, NULL, &kCFTypeDictionaryValueCallBacks);
// 根据传入的主线程获取主线程对应的RunLoop
CFRunLoopRef mainLoop = __CFRunLoopCreate(pthread_main_thread_np());
// 保存主线程 将主线程-key和RunLoop-Value保存到字典中
CFDictionarySetValue(dict, pthreadPointer(pthread_main_thread_np()), mainLoop);
if (!OSAtomicCompareAndSwapPtrBarrier(NULL, dict, (void * volatile *)&__CFRunLoops)) {
CFRelease(dict);
}
CFRelease(mainLoop);
__CFLock(&loopsLock);
}
// 从字典里面拿，将线程作为key从字典里获取一个loop
CFRunLoopRef loop = (CFRunLoopRef)CFDictionaryGetValue(__CFRunLoops, pthreadPointer(t));
__CFUnlock(&loopsLock);
// 如果loop为空，则创建一个新的loop，所以runloop会在第一次获取的时候创建
if (!loop) {
CFRunLoopRef newLoop = __CFRunLoopCreate(t);
__CFLock(&loopsLock);
loop = (CFRunLoopRef)CFDictionaryGetValue(__CFRunLoops, pthreadPointer(t));
// 创建好之后，以线程为key runloop为value，一对一存储在字典中，下次获取的时候，则直接返回字典内的runloop
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;
}
As can be seen from the above code, there is a one-to-one correspondence between threads and RunLoop, and the relationship is stored in a Dictionary. Therefore, when we create a sub-thread RunLoop, we only need to obtain the RunLoop object of the current thread in the sub-thread. [NSRunLoop currentRunLoop];If we do not obtain it, the sub-thread will not create the RunLoop associated with it, and can only obtain its RunLoop inside a thread. When the RunLoop [NSRunLoop currentRunLoop];method is called, it will first look at the dictionary to see if there is a RunLoop that is relatively used for storing child threads. If there is, it will directly return the RunLoop. If not, it will create one and store the corresponding child thread in the dictionary. When the thread ends, the RunLoop is destroyed.
6. RunLoop structure
Through the source code we find the __CFRunLoop structure
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;
CFMutableSetRef _commonModeItems;
CFRunLoopModeRef _currentMode;
CFMutableSetRef _modes;
struct _block_item *_blocks_head;
struct _block_item *_blocks_tail;
CFAbsoluteTime _runTime;
CFAbsoluteTime _sleepTime;
CFTypeRef _counterpart;
};
In addition to some record attributes, mainly look at the following two member variables
From the above analysis, we know that CFRunLoopModeRef represents the running mode of RunLoop. A RunLoop contains several Modes, and each Mode contains several Source0/Source1/Timer/Observer. When RunLoop starts, only one of the Modes can be selected as the currentMode.
What do Source1/Source0/Timers/Observer represent?
1. Source1 : Port-based inter-thread communication
The stack information is printed after the breakpoint. When the stack information printed in the xcode tool area is incomplete, the complete stack information can be printed through the "bt" command on the console. It can be found from the stack information that the touch event will indeed trigger the Source0 event.
Verify the performSelector stack information in the same way
It can be found that PerformSelectors also triggers the Source0 event
In fact, when we trigger an event (touch/lock screen/shake, etc.), an IOHIDEvent event is generated by IOKit.framework, and IOKit is Apple's hardware driver framework, which performs the abstract encapsulation of the underlying interface and interacts with the system to transmit hardware Induced events, and specially handle user interaction devices, consisting of IOHIDServices and IOHIDDisplays. Among them, IOHIDServices is dedicated to handling user interaction. It encapsulates events into IOHIDEvents objects, and then forwards them to the required App process with the mach port, and then Source1 It will receive IOHIDEvent, and then call back __IOHIDEventSystemClientQueueCallback(), trigger Source0 in __IOHIDEventSystemClientQueueCallback(), and Source0 trigger _UIApplicationHandleEventQueue(). So the touch event is seen in Source0.
4. Observer : Listener, used to monitor the status of RunLoop
7. Detailed explanation of RunLoop related classes and functions
Through the above analysis, we have a general understanding of the internal structure of RunLoop, and then we will analyze the related classes of RunLoop in detail. The following are the 5 classes of RunLoop in Core Foundation
CFRunLoopRef - get current RunLoop and main RunLoop
CFRunLoopModeRef - RunLoop operation mode, only one can be selected, and different operations can be performed in different modes
CFRunLoopSourceRef - event source, input source
CFRunLoopTimerRef - Timer time
CFRunLoopObserverRef - Observer
1. CFRunLoopModeRef
CFRunLoopModeRef represents the running mode of RunLoop. A RunLoop contains several Modes, and each Mode contains several Sources, Timers, and Observers. Each time RunLoop starts, only one of the Modes can be specified. This Mode is called CurrentMode. If you need to switch the Mode, only You can exit RunLoop, and then re-specify a Mode to enter. This is mainly to separate Source, Timer, and Observer of different groups, so that they do not affect each other. If there is no Source0/Source1/Timer/Observer in Mode, RunLoop will exit immediately as shown in the figure:
Note: There can be multiple Sources (event sources, input sources, port-based event sources such as keyboard touches, etc.) in a Mode, Observer (observer, observe the current RunLoop running state) and Timer (timer event source). But there must be at least one Source or Timer, because if Mode is empty, RunLoop will run to empty mode without idling, and will exit immediately.
There are 5 Modes registered by the system by default:
RunLoop has five operating modes, of which there are two common ones: 1.2
We must have encountered it in our development. When we use NSTimer to slide UIScrollView every time we perform something, NSTimer will pause. When we stop sliding, NSTimer will resume again. Let's take a look at it through a piece of code.
Comments in the code are also important, showing the process of our exploration
It can be seen from the above code that NSTimer does not work because of the mode switching, because if we use the timer in the main thread, the Mode of RunLoop is kCFRunLoopDefaultMode, that is, the timer belongs to kCFRunLoopDefaultMode, then when we slide the ScrollView, the RunLoop's Mode is kCFRunLoopDefaultMode. Mode will switch to UITrackingRunLoopMode, so the timer in the main thread will no longer work, and the called method will no longer be executed. When we stop sliding, the Mode of RunLoop switches back to kCFRunLoopDefaultMode, so NSTimer works again.
For the same reason, there is also the display of ImageView. Let's look at the code directly and won't repeat it.
Source0: Non-Port-based events for user-triggered events (clicking the button or clicking the screen)
Source1: Port-based sending messages to each other through the kernel and other threads (related to the kernel)
Touch events and PerformSelectors will trigger the Source0 event source, which has been verified in the previous article, so I won't go into details here.
3. CFRunLoopObserverRef
CFRunLoopObserverRef is an observer that can monitor the state change of RunLoop
Let's look at the code directly, add a listener to RunLoop, and monitor its running status
As can be seen from the above, Observer is indeed used to monitor the status of RunLoop, including wake-up, rest, and processing of various events.
Eight. RunLoop processing logic
At this time, we will analyze the processing logic of RunLoop, and it will be much simpler and clearer. Now look back at the processing logic of the official document RunLoop, and have a new understanding of the processing logic of RunLoop.
Source code analysis
The following source code only retains the main process code
In the above source code, the corresponding event processing function will also call lower-level functions, and the internal call is the function that actually handles the event. It can also be verified by printing all the stack information from the above bt.
At this point, if we rearrange the RunLoop processing logic according to the source code, it will be very clear
9. RunLoop exit
The main thread destroys RunLoop and exits
There are some Timers, Sources, and Observers in Mode. These ensure that RunLoop is not idling and is running when Mode is not empty. When Mode is empty, RunLoop will exit immediately.
The role of resident threads: We know that when the tasks in the sub-threads are executed, they are destroyed, so if we need to open a sub-thread that will always exist during the running of the program, then we will face a problem, how to To keep the child thread alive forever, a resident thread is used: open a RunLoop for the child thread Note: the child thread will be released immediately after the operation is completed, even if we use a strong reference to refer to the child thread so that the child thread will not be released, You can't add operations to the child thread again, or start it again. The code for the child thread to open RunLoop, first click the screen to open the child thread and open the child thread RunLoop, and then click the button.
Note: To create a RunLoop related to a child thread, you can create it in the child thread, and there must be at least one Timer or one Source in the RunLoop to ensure that the RunLoop will not exit due to idling, so it is added directly when it is created. Source, or just adding a listener, the running program will crash
2. Autorelease pool
Timer and Source are also some variables, which need to occupy part of the storage space, so they need to be released. If they are not released, they will keep accumulating, and the occupied memory will become larger and larger, which is obviously not what we want. So when will it be released, and how will it be released? There is an automatic release pool inside RunLoop. When RunLoop is turned on, an automatic release pool will be created automatically. When RunLoop will release the contents of the automatic release pool before resting, a new empty automatic release pool will be recreated. When it is awakened and starts running the lap again, new events such as Timer and Source will be placed in the new automatic release pool, and will also be released when RunLoop exits . Note: Only the main thread's RunLoop will start by default. This means that the automatic release pool will be created automatically, and the child thread needs to manually add the automatic release pool in the thread scheduling method.
@autorelease{
// 执行代码
}
NSTimer, ImageView display, PerformSelector, etc. have been examples above, so I won't repeat them here.
Check yourself at last
The answers to the interview questions at the beginning of the article can be found in the article, so I won't repeat them here.