EvenLoop model application example in iOS RunLoop

var thread: Thread!
func createLiveThread() {
		thread = (block: {
				let port = ()
        (port, forMode: .default)
        ()
		})
		()
}

var thread: Thread?
var isStopped: Bool = false
func createLiveThread() {
		thread = (block: { [weak self] in
				guard let self = self else { return }
				let port = ()
        (port, forMode: .default)
				while ! {
		        (mode: .default, before: )
        }
		})
		thread?.start()
}
func stop() {
		(#selector(), on: thread!, with: nil, waitUntilDone: false)
}
@objc func stopThread() {
		 = true
		(mode: .default, before: ())
     = nil
}

**public func CFRunLoopRemoveSource(_ rl: CFRunLoop!, _ source: CFRunLoopSource!, _ mode: CFRunLoopMode!)
public func CFRunLoopRemoveObserver(_ rl: CFRunLoop!, _ observer: CFRunLoopObserver!, _ mode: CFRunLoopMode!)
public func CFRunLoopRemoveTimer(_ rl: CFRunLoop!, _ timer: CFRunLoopTimer!, _ mode: CFRunLoopMode!)**

func setupImageView() {
		(onMainThread: #selector(), 
												 with: nil, 
												 waitUntilDone: false,
												 modes: [])
}
@objc func setupImage() {
		()
}

// Abstract superclass, used to act as a substitute for other objects// Timer/CADisplayLink can use NSProxy to forward messages, which can avoid circular references// We did not send NSInvocation in swift, so we directly use NSobject to forward messagesclass WeakProxy: NSObject {
    private weak var target: NSObjectProtocol?
    init(target: NSObjectProtocol) {
         = target
        ()
    }
    override func responds(to aSelector: Selector!) -> Bool {
        return (target?.responds(to: aSelector) ?? false) || (to: aSelector)
    }
    override func forwardingTarget(for aSelector: Selector!) -> Any? {
        return target
    }
}
class FPSLabel: UILabel {
    var link: CADisplayLink!
    var count: Int = 0
    var lastTime: TimeInterval = 0.0
    fileprivate let defaultSize = (width: 80, height: 20)
    override init(frame: CGRect) {
        (frame: frame)
        if  == 0 ||  == 0 {
             = defaultSize
        }
         = 5.0
        clipsToBounds = true
        textAlignment = .center
        isUserInteractionEnabled = false
        backgroundColor = (0.7)
        link = (target: (target: self), selector: #selector((link:)))
        (to: , forMode: .common)
    }
    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
    deinit {
        ()
    }
    @objc func tick(link: CADisplayLink) {
        guard lastTime != 0 else {
            lastTime = 
            return
        }
        count += 1
        let timeDuration =  - lastTime
        // 1. Set the refresh time: Here is set to 1 second (that is, refresh every second)        guard timeDuration >= 1.0 else { return }
        // 2. Calculate the current FPS        let fps = Double(count)/timeDuration
        count = 0
        lastTime = 
        // 3. Start setting up FPS        let progress = fps/60.0
        let color = UIColor(hue: CGFloat(0.27 * (progress - 0.2)), saturation: 1, brightness: 0.9, alpha: 1)
         = "\(Int(round(fps))) FPS"
         = color
    }
}

class PingMonitor {
    static let timeoutInterval: TimeInterval = 0.2
    static let queueIdentifier: String = ""
    private var queue: DispatchQueue = (label: queueIdentifier)
    private var isMonitor: Bool = false
    private var semphore: DispatchSemaphore = (value: 0)
    func startMonitor() {
        guard isMonitor == false else { return }
        isMonitor = true
         {
            while  {
                var timeout = true
                 {
                    timeout = false
                    ()
                }
                (forTimeInterval:)
                // It means that after waiting for timeoutInterval, the main thread still did not execute the dispatched task, so here it is considered that it is in a stuttering state.                if timeout == true {
                    //TODO: Here you need to remove the symbols in the crash method stack to determine why there is a stutter                    // You can use Microsoft's framework: PLCrashReporter                }
                ()
            }
        }
    }
}

class RunLoopMonitor {
    private init() {}
    static let shared: RunLoopMonitor = ()
    var timeoutCount = 0
    var runloopObserver: CFRunLoopObserver?
    var runLoopActivity: CFRunLoopActivity?
    var dispatchSemaphore: DispatchSemaphore?
    // Principle: The execution time before sleep is too long, causing it to be unable to enter sleep, or after the thread wakes up, it has not entered the next step    func beginMonitor() {
        let uptr = (self).toOpaque()
        let vptr = UnsafeMutableRawPointer(uptr)
        var context = (version: 0, info: vptr, retain: nil, release: nil, copyDescription: nil)
        runloopObserver = CFRunLoopObserverCreate(kCFAllocatorDefault,
                                                  ,
                                                  true,
                                                  0,
                                                  observerCallBack(),
                                                  &context)
        CFRunLoopAddObserver(CFRunLoopGetMain(), runloopObserver, .commonModes)
        // The initialized semaphore is 0        dispatchSemaphore = (value: 0)
        ().async {
            while true {
                // Scheme 1: You can determine by setting a single timeout time, such as 250 milliseconds								// Scheme 2: You can set multiple times of timeouts to be stuck. Dai Ming believes that three times of timeouts to be delayed for 80 seconds in GCDFetchFeed will be delayed.                let st = ?.wait(timeout: () + .milliseconds(80))
                if st == .timedOut {
                    guard  != nil else {
                         = nil
                         = nil
												 = 0
                        return
                    }
                    if  == .afterWaiting ||  == .beforeSources {
												 += 1
                        if  < 3 { continue }
                        ().async {
                            let config = (signalHandlerType: .BSD, symbolicationStrategy: .all)
                            guard let crashReporter = (configuration: config) else { return }
                            let data = ()
                            do {
                                let reporter = try (data: data)
                                let report = (for: reporter, with: PLCrashReportTextFormatiOS) ?? ""
                                NSLog("------------Stuck method stack:\n \(report)\n")
                            } catch _ {
                                NSLog("Parse crash data error")
                            }
                        }
                    }
                }
            }
        }
    }
    func end() {
        guard let _ = runloopObserver else { return }
        CFRunLoopRemoveObserver(CFRunLoopGetMain(), runloopObserver, .commonModes)
        runloopObserver = nil
    }
    private func observerCallBack() -> CFRunLoopObserverCallBack {
        return { (observer, activity, context) in
            let weakself = Unmanaged<RunLoopMonitor>.fromOpaque(context!).takeUnretainedValue()
             = activity
            ?.signal()
        }
    }
}

let runloop = CFRunLoopGetCurrent()
guard let allModes = CFRunLoopCopyAllModes(runloop) as? [CFRunLoopMode] else {
    return
}
 while true {
	  for mode in allModes {
        CFRunLoopRunInMode(mode, 0.001, false)
    }
 }

- (void)startDisplayLink:(NSString *)scene {
    FPSInfo(@"startDisplayLink");
    m_displayLink = [CADisplayLink displayLinkWithTarget:self selector:@selector(onFrameCallback:)];
    [m_displayLink addToRunLoop:[NSRunLoop currentRunLoop] forMode:NSRunLoopCommonModes];
		...
}
- (void)onFrameCallback:(id)sender {
    // Current time: unit is seconds    double nowTime = CFAbsoluteTimeGetCurrent();
    // Convert units into milliseconds    double diff = (nowTime - m_lastTime) * 1000;
		// 1. If the time interval exceeds the maximum frame interval: then the screen refresh method timed out    if (diff > ) {
        m_currRecorder.dumpTimeTotal += diff;
        m_dropTime +=  * pow(diff / , );
        // Total timeout exceeds the threshold: Display timeout information        if (m_currRecorder.dumpTimeTotal >  * ) {
            FPSInfo(@"diff %lf exceed, begin: %lf, end: %lf, scene: %@, you can see more detail in record id: %d",
                    m_currRecorder.dumpTimeTotal,
                    m_currRecorder.dumpTimeBegin,
                    m_currRecorder.dumpTimeBegin + m_currRecorder.dumpTimeTotal / 1000.0,
                    m_scene,
                    m_currRecorder.recordID);
						...... 
        }
		// 2. If the time interval does not have the maximum frame interval: then the screen refresh method does not time out    } else {
        // Total timeout exceeds the threshold: Display timeout information        if (m_currRecorder.dumpTimeTotal > ) {
            FPSInfo(@"diff %lf exceed, begin: %lf, end: %lf, scene: %@, you can see more detail in record id: %d",
                    m_currRecorder.dumpTimeTotal,
                    m_currRecorder.dumpTimeBegin,
                    m_currRecorder.dumpTimeBegin + m_currRecorder.dumpTimeTotal / 1000.0,
                    m_scene,
                    m_currRecorder.recordID);
						....
				// The total timeout does not exceed the threshold: recount the time to 0        } else {
            m_currRecorder.dumpTimeTotal = 0;
            m_currRecorder.dumpTimeBegin = nowTime + 0.0001;
        }
    }
    m_lastTime = nowTime;
}