public protocol ObservableType : ObservableConvertibleType {
 //自身将消息交给Observer，让他去处理，处理后返回一个disposable用于取消或者释放资源
 func subscribe<O: ObserverType>(_ observer: O) -> Disposable where O.E == E
}

//Observable发送Event，Observer通过on函数接收，然后执行自己的处理逻辑。
public protocol ObserverType {
    associatedtype E
    func on(_ event: Event<E>)
}

public protocol Disposable {
    /// Dispose resource.
    func dispose()
}

class Producer<Element> : Observable<Element> {
    override init() {
        super.init()
    }
    
    override func subscribe<O : ObserverType>(_ observer: O) -> Disposable where O.E == Element {
        if !CurrentThreadScheduler.isScheduleRequired {
            // The returned disposable needs to release all references once it was disposed.
            let disposer = SinkDisposer()
            let sinkAndSubscription = run(observer, cancel: disposer)
            disposer.setSinkAndSubscription(sink: sinkAndSubscription.sink, subscription: sinkAndSubscription.subscription)
            return disposer
        }
        else {
            return CurrentThreadScheduler.instance.schedule(()) { _ in
                print(Thread.current)
                let disposer = SinkDisposer()
                let sinkAndSubscription = self.run(observer, cancel: disposer)
                disposer.setSinkAndSubscription(sink: sinkAndSubscription.sink, subscription: sinkAndSubscription.subscription)
                return disposer
            }
        }
    }
    
    func run<O : ObserverType>(_ observer: O, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where O.E == Element {
        rxAbstractMethod()
    }
}

public static fileprivate(set) var isScheduleRequired: Bool {
    get {
        //从线程中获取key的值，如果是首次进入，那么会为nil，isScheduleRequired也就是true
        return pthread_getspecific(CurrentThreadScheduler.isScheduleRequiredKey) == nil
    }
    set(isScheduleRequired) {
        if pthread_setspecific(CurrentThreadScheduler.isScheduleRequiredKey, isScheduleRequired ? nil : scheduleInProgressSentinel) != 0 {
            rxFatalError("pthread_setspecific failed")
        }
    }
}

  public func schedule<StateType>(_ state: StateType, action: @escaping (StateType) -> Disposable) -> Disposable {
      //如果当前没有任务在执行，isScheduleRequired = true
      if CurrentThreadScheduler.isScheduleRequired {
          //将其设置为false,就是设置 pthread_setspecific
          CurrentThreadScheduler.isScheduleRequired = false
          //执行任务，拿到disposable
          let disposable = action(state)
          defer {
              //任务执行完毕，将isScheduleRequired设置为true
              CurrentThreadScheduler.isScheduleRequired = true
              CurrentThreadScheduler.queue = nil
          }
          //如果当前任务执行完了，queue里也没有什么东西，退出
          guard let queue = CurrentThreadScheduler.queue else {
              return disposable
          }
	//queue里还有缓存的schduledItem, 遍历执行
          while let latest = queue.value.dequeue() {
              if latest.isDisposed {
                  continue
              }
              latest.invoke()
          }
          return disposable
      }
	//isScheduleRequired为false时执行这部分代码
      let existingQueue = CurrentThreadScheduler.queue
      let queue: RxMutableBox<Queue<ScheduledItemType>>
      if let existingQueue = existingQueue {
          queue = existingQueue
      }
      else {
          queue = RxMutableBox(Queue<ScheduledItemType>(capacity: 1))
          CurrentThreadScheduler.queue = queue
      }
//构建一个ScheduledItem入队
      let scheduledItem = ScheduledItem(action: action, state: state)
      queue.value.enqueue(scheduledItem)
      return scheduledItem
  }

///初始化一个SinkDisposer
let disposer = SinkDisposer()
//调用run，得到一个sink和subscription
let sinkAndSubscription = self.run(observer, cancel: disposer)
//将sink和subscription设置到disposer里
disposer.setSinkAndSubscription(sink: sinkAndSubscription.sink, subscription: sinkAndSubscription.subscription)

///sinkdisposer的dispose
func dispose() {
    let previousState = AtomicOr(DisposeState.disposed.rawValue, &_state)
    if (previousState & DisposeStateInt32.disposed.rawValue) != 0 {
        return
    }
    if (previousState & DisposeStateInt32.sinkAndSubscriptionSet.rawValue) != 0 {
        guard let sink = _sink else {
            rxFatalError("Sink not set")
        }
        guard let subscription = _subscription else {
            rxFatalError("Subscription not set")
        }
		//前面是一坨判断，用于处理已经dispose的情况，dispose可能被调多次，原因在于Sink的dispose。
        sink.dispose()
        subscription.dispose()
        _sink = nil
        _subscription = nil
    }
}

class Sink<O : ObserverType> : Disposable {
    fileprivate let _observer: O
    fileprivate let _cancel: Cancelable
    fileprivate var _disposed: Bool
    init(observer: O, cancel: Cancelable) {
        _observer = observer
        _cancel = cancel
        _disposed = false
    }
    
    final func forwardOn(_ event: Event<O.E>) {
        if _disposed {
            return
        }
        _observer.on(event)
    }
    //SinkForward也封装了on方法，和forwardOn的区别在于，会调用cancel.dispose。
    final func forwarder() -> SinkForward<O> {
        return SinkForward(forward: self)
    }
    final var disposed: Bool {
        return _disposed
    }
    func dispose() {
        _disposed = true
        _cancel.dispose()
    }
}

///只是简单的对on方法的封装
final class SinkForward<O: ObserverType>: ObserverType {
    typealias E = O.E
    
    private let _forward: Sink<O>
    
    init(forward: Sink<O>) {
        _forward = forward
    }
    
    final func on(_ event: Event<E>) {
        switch event {
        case .next:
            _forward._observer.on(event)
        case .error, .completed:
            _forward._observer.on(event)
            _forward._cancel.dispose()
        }
    }
}

public static func just(_ element: E) -> Observable<E> {
    return Just(element: element)
}

//继承自producer
final fileprivate class Just<Element> : Producer<Element> {
private let _element: Element
init(element: Element) {
    _element = element
}
///做了优化，不是重写run方法，而是直接重写subscribe，observer.on，然后返回NopDisposable。
override func subscribe<O : ObserverType>(_ observer: O) -> Disposable where O.E == Element {
    observer.on(.next(_element))
    observer.on(.completed)
    return Disposables.create()
}
}

public static func just(_ element: E, scheduler: ImmediateSchedulerType) -> Observable<E> {
    return JustScheduled(element: element, scheduler: scheduler)
}

//也是继承producer
final fileprivate class JustScheduled<Element> : Producer<Element> {
    fileprivate let _scheduler: ImmediateSchedulerType
    fileprivate let _element: Element
    init(element: Element, scheduler: ImmediateSchedulerType) {
        _scheduler = scheduler
        _element = element
    }
  //重写run方法，将observer.on这部分代码，交给Sink去实现
    override func run<O : ObserverType>(_ observer: O, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where O.E == E {
        //sink持有cancelable,也就是Producer中的SinkDispose。当on接收了所有sequence之后调用了Sink的dispose，Sink的dispose会调用cancelable的dispose。cancelable实际上有持有sink和subscruption。此时sink是已经dispose的了，不会再次执行，subscruption的dispose正常执行。
        let sink = JustScheduledSink(parent: self, observer: observer, cancel: cancel)
        let subscription = sink.run()
        return (sink: sink, subscription: subscription)
    }
}

final fileprivate class JustScheduledSink<O: ObserverType> : Sink<O> {
    typealias Parent = JustScheduled<O.E>
    private let _parent: Parent
    init(parent: Parent, observer: O, cancel: Cancelable) {
        _parent = parent
        super.init(observer: observer, cancel: cancel)
    }
    //调用Observer.on
    func run() -> Disposable {
        let scheduler = _parent._scheduler
        return scheduler.schedule(_parent._element) { element in
            self.forwardOn(.next(element))
            return scheduler.schedule(()) { _ in
                self.forwardOn(.completed)
				//既然sinkDisposer都已经释放了，我们自己创建一个什么也不做的disposable返回
                self.dispose()
                return Disposables.create()
            }
        }
    }
}

public final class PublishSubject<Element>
    : Observable<Element>
    , SubjectType
    , Cancelable
    , ObserverType
    , SynchronizedUnsubscribeType {
    public typealias SubjectObserverType = PublishSubject<Element>
    typealias Observers = AnyObserver<Element>.s
    typealias DisposeKey = Observers.KeyType
    
    /// Indicates whether the subject has any observers
    public var hasObservers: Bool {
        _lock.lock()
        let count = _observers.count > 0
        _lock.unlock()
        return count
    }
    
    private let _lock = RecursiveLock()
    
    // state
    private var _isDisposed = false
    private var _observers = Observers()//一个Bag,保存了所有Observer的on方法
    private var _stopped = false
    private var _stoppedEvent = nil as Event<Element>?
    #if DEBUG
        fileprivate let _synchronizationTracker = SynchronizationTracker()
    #endif
    /// Indicates whether the subject has been isDisposed.
    public var isDisposed: Bool {
        return _isDisposed
    }
    
    /// Creates a subject.
    public override init() {
        super.init()
        #if TRACE_RESOURCES
            _ = Resources.incrementTotal()
        #endif
    }
    
    /// 可以通过on方法接收事件，接收后，如果连接的有任何observer会将event发送给他们
    public func on(_ event: Event<Element>) {
        dispatch(_synchronized_on(event), event)
    }
    func _synchronized_on(_ event: Event<E>) -> Observers {
        _lock.lock(); defer { _lock.unlock() }
        switch event {
        case .next(_):
            if _isDisposed || _stopped {
                return Observers()
            }
            
            return _observers
        case .completed, .error:
            if _stoppedEvent == nil {
                _stoppedEvent = event
                _stopped = true
                let observers = _observers
                _observers.removeAll()
                return observers
            }
            return Observers()
        }
    }
    
    //当subjectsubscribe某个observer，实际上是将其添加到了自己的Observers中。
    public override func subscribe<O : ObserverType>(_ observer: O) -> Disposable where O.E == Element {
        _lock.lock()
        let subscription = _synchronized_subscribe(observer)
        _lock.unlock()
        return subscription
    }
    func _synchronized_subscribe<O : ObserverType>(_ observer: O) -> Disposable where O.E == E {
        //如果已经stop了，返回一个stoppedEvent
        if let stoppedEvent = _stoppedEvent {
            observer.on(stoppedEvent)
            return Disposables.create()
        }
        //如果已经dispose了，返回一个Error
        if _isDisposed {
            observer.on(.error(RxError.disposed(object: self)))
            return Disposables.create()
        }
        //将observer的on方法插入observers，并得到一个key，返回一个SubscriptionDisposable，在他dispose时会通过key移除对应的on。
        let key = _observers.insert(observer.on)
        return SubscriptionDisposable(owner: self, key: key)
    }
    //SubscriptionDisposable dispose时会调用他
    func synchronizedUnsubscribe(_ disposeKey: DisposeKey) {
        _lock.lock()
        _synchronized_unsubscribe(disposeKey)
        _lock.unlock()
    }
    func _synchronized_unsubscribe(_ disposeKey: DisposeKey) {
        //通过key移除对应的on。
        _ = _observers.removeKey(disposeKey)
    }
    
    /// Returns observer interface for subject.
    public func asObserver() -> PublishSubject<Element> {
        return self
    }
    
    /// Unsubscribe all observers and release resources.
    public func dispose() {
        _lock.lock()
        _synchronized_dispose()
        _lock.unlock()
    }
    final func _synchronized_dispose() {
        _isDisposed = true
        _observers.removeAll()
        _stoppedEvent = nil
    }
    #if TRACE_RESOURCES
        deinit {
            _ = Resources.decrementTotal()
        }
    #endif
}

class Foo {
    var x: Int = 0
    var y: String = ""
    func doSomething() {
        print("Hello, world!")
    }
}
let foo = Foo()
let mirror = Mirror(reflecting: foo)
for property in mirror.children {
    print("\(property.label!): \(property.value)")
}

public init(reflecting subject: Any) {
    if case let customized as CustomReflectable = subject {
      self = customized.customMirror
    } else {
      self = Mirror(internalReflecting: subject)
    }
}

  internal init(internalReflecting subject: Any,
              subjectType: Any.Type? = nil,
              customAncestor: Mirror? = nil)
  {
     //从typemeta中取出subjectType
    let subjectType = subjectType ?? _getNormalizedType(subject, type: type(of: subject))
    //从typemeta中取出childCount
    let childCount = _getChildCount(subject, type: subjectType)
    //从typemeta中取出所有value，组成children
    let children = (0 ..< childCount).lazy.map({
      getChild(of: subject, type: subjectType, index: $0)
    })
    self.children = Children(children)
    
    self._makeSuperclassMirror = {
      guard let subjectClass = subjectType as? AnyClass,
            let superclass = _getSuperclass(subjectClass) else {
        return nil
      }
      
      // 处理custom ancestors
      if let customAncestor = customAncestor {
        if superclass == customAncestor.subjectType {
          return customAncestor
        }
        if customAncestor._defaultDescendantRepresentation == .suppressed {
          return customAncestor
        }
      }
      return Mirror(internalReflecting: subject,
                    subjectType: superclass,
                    customAncestor: customAncestor)
    }
    //取出DisplayStyle
    let rawDisplayStyle = _getDisplayStyle(subject)
    switch UnicodeScalar(Int(rawDisplayStyle)) {
    case "c": self.displayStyle = .class
    case "e": self.displayStyle = .enum
    case "s": self.displayStyle = .struct
    case "t": self.displayStyle = .tuple
    case "\0": self.displayStyle = nil
    default: preconditionFailure("Unknown raw display style '\(rawDisplayStyle)'")
    }
    
    self.subjectType = subjectType
    self._defaultDescendantRepresentation = .generated
}

struct StructImpl : ReflectionMirrorImpl {
  bool isReflectable() {
    const auto *Struct = static_cast<const StructMetadata *>(type);
    const auto &Description = Struct->getDescription();
    return Description->getTypeContextDescriptorFlags().isReflectable();
  }
  char displayStyle() {
    return 's';
  }
  
   /** 返回成员变量数量 */
  intptr_t count() {
    if (!isReflectable()) {
      return 0;
    }
    /** 可以看到，这里将我们的传入的type，转为StructMetadata，然后再从中获取信息 */
    auto *Struct = static_cast<const StructMetadata *>(type);
    return Struct->getDescription()->NumFields;
  }
  
   /** 返回成员变量值 */
  AnyReturn subscript(intptr_t i, const char **outName,
                      void (**outFreeFunc)(const char *)) {
     /**   这里也是一样   */ 
    auto *Struct = static_cast<const StructMetadata *>(type);
    if (i < 0 || (size_t)i > Struct->getDescription()->NumFields)
      swift::crash("Swift mirror subscript bounds check failure");
    // Load the offset from its respective vector.
    auto fieldOffset = Struct->getFieldOffsets()[i];
    Any result;
    
    _swift_getFieldAt(type, i, [&](llvm::StringRef name, FieldType fieldInfo) {
      assert(!fieldInfo.isIndirect() && "indirect struct fields not implemented");
      
      *outName = name.data();
      *outFreeFunc = nullptr;
      
      auto *bytes = reinterpret_cast<char*>(value);
      auto *fieldData = reinterpret_cast<OpaqueValue *>(bytes + fieldOffset);
      
      bool didLoad = loadSpecialReferenceStorage(fieldData, fieldInfo, &result);
      if (!didLoad) {
        result.Type = fieldInfo.getType();
        auto *opaqueValueAddr = result.Type->allocateBoxForExistentialIn(&result.Buffer);
        result.Type->vw_initializeWithCopy(opaqueValueAddr,
                                           const_cast<OpaqueValue *>(fieldData));
      }
    });
    return AnyReturn(result);
  }
};

struct TargetMetadata {
   StoredPointer Kind;
}

struct Person {
    var age:Int64 = 0 
    var sex:UInt16 = 0
    var address:Double = 0.0
    var name:UInt8 = 0
}
开始设置size = 0 ，alignment = 1
age是8字节对其，size为0，没问题，不需要调整。
age是8字节，size增加8
age的alignment为8，更新alignment为Max(1,8)
sex为2字节对其,size为8，没问题，不用调整。
sex是2字节，size增加2，为10
sex的alignment为2，更新alignment为Max(8,2)
address为8字节对其,size为10，需调整size为16，来保证对其。
address是8字节，size增加8，为24
address的alignment为8，更新alignment为Max(8,8)
name为1字节对其,size为24，不用调整。
name是1字节，size增加1，为25
name的alignment为1，更新alignment为Max(8,1)
所以size为25， alignment为8， 调整strip为32，保证对其。

class Person {
    var age = 0x0101010101010101
    var money =  0x0202020202020202
}
let p = Person()

//看看每一位表示什么(64位情况)
template <>
struct RefCountBitOffsets<8> {
  static const size_t IsPinnedShift = 0;
  static const size_t IsPinnedBitCount = 1; 
  static const uint64_t IsPinnedMask = maskForField(IsPinned);
  static const size_t UnownedRefCountShift = shiftAfterField(IsPinned);
  static const size_t UnownedRefCountBitCount = 31;
  static const uint64_t UnownedRefCountMask = maskForField(UnownedRefCount);
  static const size_t IsDeinitingShift = shiftAfterField(UnownedRefCount);
  static const size_t IsDeinitingBitCount = 1;
  static const uint64_t IsDeinitingMask = maskForField(IsDeiniting);
  static const size_t StrongExtraRefCountShift = shiftAfterField(IsDeiniting);
  static const size_t StrongExtraRefCountBitCount = 30;
  static const uint64_t StrongExtraRefCountMask = maskForField(StrongExtraRefCount);
  static const size_t UseSlowRCShift = shiftAfterField(StrongExtraRefCount);
  static const size_t UseSlowRCBitCount = 1;
  static const uint64_t UseSlowRCMask = maskForField(UseSlowRC);
  static const size_t SideTableShift = 0;
  static const size_t SideTableBitCount = 62;
  static const uint64_t SideTableMask = maskForField(SideTable);
  static const size_t SideTableUnusedLowBits = 3;
  static const size_t SideTableMarkShift = SideTableBitCount;
  static const size_t SideTableMarkBitCount = 1;
  static const uint64_t SideTableMarkMask = maskForField(SideTableMark);
};
===============================
低位---》高位
1位         IsPinned
31位        UnownedRefCountBit
1位         IsDeiniting
30位        StrongExtraRefCount
1位         UseSlowRC
如果是有sidetable的情况，各个bit表示如下：
62位        SideTable指针
1位         SideTableMark
1位         UseSlowRC

class Person {
    var age = 0x0102030405060708
    var money =  0x0202020202020202
    func sayHello()  {
        print("hello")
    }
    func sayWorld()  {
        print("world")
    }
}
let p1 = Person()
let p2 = p1
let p3 = p1
let p4 = p1
let p5 = p1
unowned var p6 = p1
unowned var p7 = p1
dumpAndOpenGraph(dumping: p1, maxDepth: 10, filename: "SimpleClassPerson")

weak var p8 = p1

Class {
    isa
    supperclass
    cache
    各种method指针
}

enum Empty {} // => empty type
此时size为0， alignment为1， 为了对齐strip为1

enum EmptyCase { case X }             // => empty type
enum DataCase { case Y(Int, Double) } // => LLVM <{ i64, double }>
EmptyCase size为0 ，alignment 为1，strip为1
DataCase 布局就是1个Int,Double。所以size为16，alignment为8，strip为16

enum EnumLike2 { // => LLVM i1
  case A         // => i1 0
  case B         // => i1 1
}
enum EnumLike8 { // => LLVM i3
  case A         // => i3 0
  case B         // => i3 1
  case C         // => i3 2
  case D         // etc.
  case E
  case F
  case G
  case H
}
size为1， alignment为1，strip为1。为什么是1呢，因为1个字节可以表示2的8次方种情况，足够表示这么多case了。那超过了呢？
又比如
enum A {
    case A0
    case A1
    ....
    case A280
}
此时不足以用1个字节表示所以，size为2，alignment为2，strip为2.

32位足够描述所有情况，就用这么多
enum CharOrSectionMarker { //=> LLVM i32
  case Paragraph           // => i32 0x0020_0000
  case Char(UnicodeScalar) // => i32 (zext i21 %Char to i32)
  case Chapter             // => i32 0x0020_0001
}
CharOrSectionMarker.Char('\x00') => i32 0x0000_0000
CharOrSectionMarker.Char('\u10FFFF') => i32 0x0010_FFFF
enum CharOrSectionMarkerOrFootnoteMarker { => LLVM i32
  case CharOrSectionMarker(CharOrSectionMarker) => i32 %CharOrSectionMarker
  case Asterisk                                 => i32 0x0020_0002
  case Dagger                                   => i32 0x0020_0003
  case DoubleDagger                             => i32 0x0020_0004
}

//不够了，总的情况为Int描述的+2，超出了Int8字节能表示的访问，就在末尾增加一个字节来区分就是是有data还是没data。
enum IntOrInfinity { => LLVM <{ i64, i1增加一位区分有没data type }>
  case NegInfinity    => <{ i64, i1 }> {    0, 1 }
  case Int(Int)       => <{ i64, i1 }> { %Int, 0 }
  case PosInfinity    => <{ i64, i1 }> {    1, 1 }
}
IntOrInfinity.Int(    0) => <{ i64, i1 }> {     0, 0 }
IntOrInfinity.Int(20721) => <{ i64, i1 }> { 20721, 0 }
size为9，alignment为8，strip为16

class Bignum {}
enum IntDoubleOrBignum { => LLVM <{ i64, i2增加两位区分3中情况 }>
  case Int(Int)           => <{ i64, i2 }> {           %Int,            0 }
  case Double(Double)     => <{ i64, i2 }> { (bitcast  %Double to i64), 1 }
  case Bignum(Bignum)     => <{ i64, i2 }> { (ptrtoint %Bignum to i64), 2 }
}
size为9，alignment为8，strip为16

struct OpaqueExistentialContainer {
  void *fixedSizeBuffer[3];//数据区
  Metadata *type;//数据区的类型
  WitnessTable *witnessTables[NUM_WITNESS_TABLES];//protocol的witnesstable
};

struct StructSmallP: P {
    func f() {}
    func g() {}
    func h() {}
    var a = 0x6c6c616d73
    var b = 0x6c6c616d73
}
let p = StructSmallP()
dumpAndOpenGraph(dumping:p , maxDepth: 4, filename: "StructSmallP")

let p:P = StructSmallP()//定义为P
dumpAndOpenGraph(dumping:p , maxDepth: 4, filename: "StructSmallP")

let objs = [ClassA(),ClassB(),ClassC()]