点击之后打印 主线程，Why

        DispatchQueue.global().async {
            print("请求数据")
            self.button.rx.tap.subscribe(onNext: { () in
                print("tap = --- \(Thread.current)")
            })
        }
请求数据
tap = --- <NSThread: 0x600000ca5b80>{number = 1, name = main}

步骤1：点击tap

    public var tap: ControlEvent<Void> {
        return controlEvent(.touchUpInside)
    }

步骤2：点击controlEvent( )

2.1 方法controlEvent返回ControlEvent
2.2 .create{} 闭包中已经是主线程，MainScheduler.ensureRunningOnMainThread()这是一个说明
2.3 现在就要看这个闭包执行之前做了什么操作
2.4 2.1方法的返回值ControlEvent执行.subscribe(onNext: ) -> 3.1 ControlEvent..subscribe(onNext: )
2.5 return ControlEvent(events: source) 会来到 4.1传入source 然后source依附在ConcurrentMainScheduler.instance上

    public func controlEvent(_ controlEvents: UIControl.Event) -> ControlEvent<()> {
        let source: Observable<Void> = Observable.create { [weak control = self.base] observer in
                MainScheduler.ensureRunningOnMainThread()

                guard let control = control else {
                    observer.on(.completed)
                    return Disposables.create()
                }
                let controlTarget = ControlTarget(control: control, controlEvents: controlEvents) { _ in
                    observer.on(.next(()))
                }
                return Disposables.create(with: controlTarget.dispose)
            }
            .takeUntil(deallocated)

        return ControlEvent(events: source)
    }

步骤3：点击外界 .subscribe(onNext: )

3.1 ControlEvent.subscribe(onNext: )
3.2 return Disposables.create( self.asObservable().subscribe(observer), disposable ) -> ControlEvent执行subscribe()

    public func subscribe(onNext: ((Element) -> Void)? = nil, onError: ((Swift.Error) -> Void)? = nil, onCompleted: (() -> Void)? = nil, onDisposed: (() -> Void)? = nil)
        -> Disposable {
            let disposable: Disposable
            
            if let disposed = onDisposed {
                disposable = Disposables.create(with: disposed)
            }
            else {
                disposable = Disposables.create()
            }
            
            #if DEBUG
                let synchronizationTracker = SynchronizationTracker()
            #endif
            
            let callStack = Hooks.recordCallStackOnError ? Hooks.customCaptureSubscriptionCallstack() : []
            
            let observer = AnonymousObserver<Element> { event in
                
                #if DEBUG
                    synchronizationTracker.register(synchronizationErrorMessage: .default)
                    defer { synchronizationTracker.unregister() }
                #endif
                
                switch event {
                case .next(let value):
                    onNext?(value)
                case .error(let error):
                    if let onError = onError {
                        onError(error)
                    }
                    else {
                        Hooks.defaultErrorHandler(callStack, error)
                    }
                    disposable.dispose()
                case .completed:
                    onCompleted?()
                    disposable.dispose()
                }
            }
            return Disposables.create(
                self.asObservable().subscribe(observer),
                disposable
            )
    }

步骤4：ControlEvent执行subscribe() 来到 ControlEvent结构体
4.1 public init<Ev: ObservableType>(events: Ev) where Ev.Element == Element { self._events = events.subscribeOn(ConcurrentMainScheduler.instance) } 初始化ControlEvent，传入的source依附在ConcurrentMainScheduler.instance上，赋值给self._events
4.2 ControlEvent实现了 ObservableType协议的subscribe方法
4.3 执行self._events.subscribe(observer)，可观察序列执行(2.5传入的序列，但是依附在ConcurrentMainScheduler.instance伞了)subscribe，回到2.2闭包，OK 完美

public struct ControlEvent<PropertyType> : ControlEventType {
    public typealias Element = PropertyType

    let _events: Observable<PropertyType>

    /// Initializes control event with a observable sequence that represents events.
    ///
    /// - parameter events: Observable sequence that represents events.
    /// - returns: Control event created with a observable sequence of events.
    public init<Ev: ObservableType>(events: Ev) where Ev.Element == Element {
        self._events = events.subscribeOn(ConcurrentMainScheduler.instance)
    }

    /// Subscribes an observer to control events.
    ///
    /// - parameter observer: Observer to subscribe to events.
    /// - returns: Disposable object that can be used to unsubscribe the observer from receiving control events.
    public func subscribe<Observer: ObserverType>(_ observer: Observer) -> Disposable where Observer.Element == Element {
        return self._events.subscribe(observer)
    }

    /// - returns: `Observable` interface.
    public func asObservable() -> Observable<Element> {
        return self._events
    }

    /// - returns: `ControlEvent` interface.
    public func asControlEvent() -> ControlEvent<Element> {
        return self
    }
}

步骤5：点击instance
5.1 MainScheduler.instance 主线程 回到4.1

    public static let instance = ConcurrentMainScheduler(mainScheduler: MainScheduler.instance)

有点问题需要修改

请求数据
(lldb) po self.button.rx.tap
▿ ControlEvent<()>
  ▿ _events : <SubscribeOn<Observable<()>>: 0x60000203c300>