參考：

• https://hubo.dev/2020-05-11-source-code-walkthrough-of-telegram-ios-part-2
• Telegram-iOS 源碼分析：第二部分（SSignalKit）
• RxSwift核心

與Rxswif類似，主要包含的內(nèi)容：Signal,Subscriber，Disposable

Disposable

Disposable： 一個(gè)協(xié)議，包含有func dispose()的方法
StrictDisposable: Disposable：通過xxdispose.strict()獲取
_EmptyDisposable: Disposable: 直接使用EmptyDisposable獲取全局同一個(gè)
ActionDisposable: Disposable: 在dispose或deinit時(shí)會(huì)執(zhí)行一個(gè)action的block回調(diào)
MetaDisposable: Disposable: 內(nèi)部包含一個(gè)dispose，并且可以替換
DisposableSet: Disposable: 內(nèi)部包含一組使用Array管理的dispose集合，并且添加或刪除新的dispo，dispose()時(shí)會(huì)調(diào)用所有子dispose對(duì)象的dispose()方法
DisposableDict: Disposable: 內(nèi)部包含使用Dict管理的dispose集合，并且通過Key設(shè)置dispose，dispose()時(shí)會(huì)調(diào)用所有子dispose對(duì)象的dispose()方法

Subscriber

Subscriber:
有next,error,completed回調(diào)
有pubNext,putError,putCompletion方法

Signal

Signal: 信號(hào)，只有一個(gè)start(xxx)方法，只要執(zhí)行start，就會(huì)生成一個(gè)subscriber，同時(shí)調(diào)用generator回調(diào)
Signal創(chuàng)建方式一，使用generator創(chuàng)建:

 Signal { subscriber in
        // ... 義務(wù)處理
        return xxxDispose
    }

其他默認(rèn)方式
Signal.single(xxx)
Signal.complete()
Signal.fail(xxx)
Signal.never()

Promise

Promise:
內(nèi)部有一個(gè)存放數(shù)據(jù)的value, 訂閱者列表subscribers
set(xxxSignal): 用來設(shè)置信號(hào)替換value,同時(shí)觸發(fā)xxxSignal的generator回調(diào)
get(): 用來增加一個(gè)訂閱者信號(hào)，通過該信號(hào)的start()獲取Promise里的value

 func testPromise1() {
    print("======testPromise1======")
    
    let promise1 = Promise<String>()
    // 由于第一次獲取時(shí)，沒有值，不會(huì)觸發(fā)回調(diào)
    var promise1Value: String? = nil
    let dispose0 = promise1.get().start(next: { list in
        print("\(Date()) dispose0 get1--\(list)")
        promise1Value = list
    })
    dispose0.dispose()
    let promise1Value2 = promise1.rawValue
    print("\(Date()) promise1Value--\(promise1Value ?? "nil") promise1Value2:\(promise1Value2 ?? "nil")")
    // 由于第一次獲取時(shí)，沒有值，不會(huì)觸發(fā)回調(diào)
    let dispose1 = promise1.get().start(next: { list in
        print("\(Date()) dispose1 get1--\(list)")
    })
    // 設(shè)置Signal后，會(huì)立即執(zhí)行signal的generator, 通過next拿到generatoer里設(shè)置的putNext()的值
    // 獲取到值后，會(huì)回調(diào)執(zhí)行所有g(shù)et()創(chuàng)建的subscriber
    promise1.set(Signal<String, NoError> { subscriber in
        // 會(huì)觸發(fā)此刻已經(jīng)存在的所有g(shù)et()創(chuàng)建的所有監(jiān)聽者
        print("\(Date()) 設(shè)置值--aaa")
        subscriber.putNext("aaaa")
        DispatchQueue.global().asyncAfter(deadline: .now() + 2, execute: {
            // 會(huì)觸發(fā)此刻已經(jīng)存在的所有g(shù)et()創(chuàng)建的所有監(jiān)聽者
            print("\(Date()) 設(shè)置值--bbb")
            subscriber.putNext("bbb")
        })
        return MetaDisposable()
    })
    // 由于promise里已經(jīng)有值了，直接獲取存在的值
    let dispose2 = promise1.get().start(next: { list in
        print("\(Date()) dispose2 get2--\(list)")
    })
    let promise1Value3 = promise1.rawValue
    print("\(Date()) promise1Value3:\(promise1Value3 ?? "nil")")
    /**
     ======testPromise1======
     2024-02-24 08:23:38 +0000 promise1Value--nil promise1Value2:nil
     2024-02-24 08:23:38 +0000 設(shè)置值--aaa
     2024-02-24 08:23:38 +0000 dispose1 get1--aaaa
     2024-02-24 08:23:38 +0000 dispose2 get2--aaaa
     2024-02-24 08:23:38 +0000 promise1Value3:aaaa
     2024-02-24 08:23:40 +0000 設(shè)置值--bbb
     2024-02-24 08:23:40 +0000 dispose1 get1--bbb
     2024-02-24 08:23:40 +0000 dispose2 get2--bbb
     */
}
// 使用使用完立即銷毀的方式獲取默認(rèn)值
extension Promise {
    var rawValue: T? {
        get {
            // 通過get獲取signal，調(diào)用start()獲取最新的值并添加subscriber
            var valueObj: T? = nil
            let valueDispose = self.get().start { value in
                // 如果當(dāng)前值為空時(shí)不會(huì)走這個(gè)回調(diào)，如果值不為空時(shí)會(huì)走這個(gè)回調(diào)
                valueObj = value
            }
            // 銷毀了dispose，后續(xù)value值變化也不會(huì)觸發(fā)上面的賦值操作
            valueDispose.dispose()
            // 返回獲取的值
            return valueObj
        } set {
            if let val = newValue {
                self.set(Signal {subscriber in
                    subscriber.putNext(val)
                    return EmptyDisposable
                })
            }
        }
    }
}

利用Promise的默認(rèn)值為nil，異步設(shè)置的特點(diǎn)特別適合網(wǎng)絡(luò)請(qǐng)求的場(chǎng)景
1、進(jìn)入一個(gè)頁面后立即開始網(wǎng)絡(luò)請(qǐng)求數(shù)據(jù)，網(wǎng)絡(luò)請(qǐng)求完成后設(shè)置值并刷新頁面

func testPromise2() {
    print("======testPromise2======")
    // 這里可以設(shè)置默認(rèn)值，如果有的話
    let networkPromise = Promise<String>()
    networkPromise.rawValue = UserDefaults.standard.string(forKey: "net1")
   
    // 設(shè)置Signal后，會(huì)立即執(zhí)行signal的generator, 通過next拿到generatoer里設(shè)置的putNext()的值
    // 獲取到值后，會(huì)回調(diào)執(zhí)行所有g(shù)et()創(chuàng)建的subscriber
    networkPromise.set(Signal<String, NoError> { subscriber in
        guard let url = URL(string: "https://reqres.in/api/users/2") else {
            subscriber.putCompletion()
            return EmptyDisposable
        }
        let request = URLRequest(url: url)
        let task = URLSession.shared.dataTask(with: request, completionHandler: {data, response, error in
            if let data = data {
                // 數(shù)據(jù)請(qǐng)求成功
                var respStr = String(data: data, encoding: .utf8) ?? "--"
                respStr = "response--Data"
                UserDefaults.standard.setValue(respStr, forKey: "net1")
                print("網(wǎng)絡(luò)請(qǐng)求成功----")
                subscriber.putNext(respStr)
            } else {
                // 如果有錯(cuò)誤
                subscriber.putCompletion()
            }
        })
        // 開始請(qǐng)求
        task.resume()
        // 發(fā)起網(wǎng)絡(luò)請(qǐng)求
        return ActionDisposable {
            // 如果銷毀了，可以將網(wǎng)絡(luò)請(qǐng)求取消
            task.cancel()
        }
    })
    // 監(jiān)聽數(shù)據(jù)，有數(shù)據(jù)變化才刷新
    let uiDispose = (networkPromise.get() |> distinctUntilChanged
    ).start(next: { str in
        // 網(wǎng)絡(luò)請(qǐng)求后有數(shù)據(jù)變化，更新UI
        print("更新UI: \(str)")
    }, completed: {
        print("更新UI: completed")
    })
}

ValuePromise:
內(nèi)部有一個(gè)存放數(shù)據(jù)的value, 訂閱者列表subscribers
set(xxx): 用來設(shè)置新值替換value,同時(shí)觸發(fā)所有的subscribers的next
get(): 用來增加一個(gè)訂閱者信號(hào),并在start()時(shí)加入到subscribers

func testValuePromise1() {
    print("======testValuePromise1======")
    let promise1 = ValuePromise("testA", ignoreRepeated: true)
    var promise1Value: String = "nil"
    print("promise1Value: \(promise1Value)")
    let promise1Dispose1 = promise1.get().start { value in
        print("promise1Dispose1-next:\(value)")
        promise1Value = value
    }
    // promise1Dispose1沒在start時(shí)，會(huì)獲取最新的值，所以promise1Value會(huì)變成最新的 testA
    print("promise1Value: \(promise1Value)")
    // 設(shè)置新值,這里由于promise1Dispose1還沒有銷毀，這里的set也會(huì)觸發(fā)收到值
    promise1.set(promise1Value + "---" + "testB")
    
    // 重新獲取，在start時(shí)會(huì)獲取最新的值 testA---testB
    let promise1Dispose2 = promise1.get().start { value in
        print("promise1Dispose2-next: \(value)")
    }
    // promise1Dispose1沒有銷毀，會(huì)最新的設(shè)置也會(huì)生效，所以promise1Value會(huì)變成最新的 testA---testB
    print("promise1Value: \(promise1Value)")
    promise1Dispose1.dispose()
    promise1Dispose2.dispose()
    /**
        ======testValuePromise1======
        promise1Value: nil
        promise1Dispose1-next:testA
        promise1Value: testA
        promise1Dispose1-next:testA---testB
        promise1Dispose2-next: testA---testB
        promise1Value: testA---testB
        */
}
    
func testValuePromise2() {
    print("======testValuePromise2======")
    let promise2 = ValuePromise("testX", ignoreRepeated: true)
    var promise2Value: String = "nil"
    print("promise2Value: \(promise2Value)")
    let promise2Dispose1 = promise2.get().start { value in
        print("promise2Dispose1-next:\(value)")
        promise2Value = value
        
    }
    // 銷毀了dispose，promise2Dispose1對(duì)應(yīng)的subscriber也會(huì)被銷毀，后續(xù)再給promise2設(shè)置時(shí)，promise2Dispose1再也不會(huì)處理了
    promise2Dispose1.dispose()
    // promise2Dispose1沒在start時(shí)，會(huì)獲取最新的值，所以promise2Value會(huì)變成最新的 testX
    print("promise2Value: \(promise2Value)")
    
    // 設(shè)置新值,這里由于promise1Dispose1還沒有銷毀，這里的set不會(huì)觸發(fā)被銷毀的subscriber
    promise2.set(promise2Value + "---" + "testY")
    
    // 重新獲取，在start時(shí)會(huì)獲取最新的值 test1---testB
    let promise2Dispose2 = promise2.get().start { value in
        print("promise2Dispose2-next: \(value)")
    }
    // 所以promise2Value會(huì)變成最新的 testX
    print("promise2Value: \(promise2Value)")
    promise2Dispose2.dispose()
    /**
        ======testValuePromise2======
        promise2Value: nil
        promise2Dispose1-next:testX
        promise2Value: testX
        promise2Dispose2-next: testX---testY
        promise2Value: testX
        */
}

使用ValuePromise的特性，可以增加擴(kuò)展方法直接獲取不可以訪問的值

extension ValuePromise {
    var rawValue: T {
        // 通過get獲取signal，調(diào)用start()獲取最新的值并添加subscriber
        var valueObj: T!
        let valueDispose = self.get().start { value in
            valueObj = value
            
        }
        // 銷毀了dispose，將valueDispose對(duì)應(yīng)的subscriber也會(huì)被銷毀
        valueDispose.dispose()
        // 返回獲取的值
        return valueObj
    }
}
func testValuePromise3() {
    print("======testValuePromise3======")
    let promise3 = ValuePromise("aaa", ignoreRepeated: true)
    let promise3Value = promise3.rawValue
    print("promise3Value: \(promise3Value)")
    
    promise3.set(promise3Value + "---" + "bbb")
    
    // 重新獲取，在start時(shí)會(huì)獲取最新的值 test1---testB
    let promise3Dispose2 = promise3.get().start { value in
        print("promise3Dispose2-next: \(value)")
    }
    // 所以promise2Value會(huì)變成最新的 testX
    print("promise3Value: \(promise3Value)")
    promise3Dispose2.dispose()
    /**
        ======testValuePromise3======
        promise3Value: aaa
        promise3Dispose2-next: aaa---bbb
        promise3Value: aaa
        */
}

Bag

Bag：跟數(shù)組Array的功能差不多，有get，add，remove等功能
SparseBag: Sequence: 同樣是組數(shù)的基本功能
CounterBag: 用于維護(hù)一個(gè)計(jì)數(shù)的類，沒什么特別的功能

Atomic

一個(gè)普通的對(duì)數(shù)據(jù)持有的封裝，在線程安全的方式修改數(shù)據(jù)，可以對(duì)持有的數(shù)據(jù)進(jìn)行轉(zhuǎn)換主要方法：
with: 將數(shù)據(jù)轉(zhuǎn)換為其他內(nèi)容并返回轉(zhuǎn)換后的類型，并不修改自己持有的數(shù)據(jù)，類似map
modify: 將數(shù)據(jù)轉(zhuǎn)換為同類型的其他數(shù)據(jù)，并將轉(zhuǎn)換好的數(shù)據(jù)替換自己的數(shù)據(jù)，同時(shí)返回替換后的數(shù)據(jù),比map多了修改持有的數(shù)據(jù)
swap: 將同類型的新數(shù)據(jù)替換舊數(shù)據(jù)，同時(shí)返回舊數(shù)據(jù)