Rill：Go語言中併發+事務的批處理開源專案

Rill（名詞：小流）是一個用於流式傳輸、並行處理和管道構建的綜合 Go 工具包。它旨在減少樣板檔案並簡化使用，使開發人員能夠專注於核心邏輯，而不會因併發的複雜性而陷入困境。

透過通道轉換、型別安全、批處理和錯誤處理實現併發。

設計理念
rill 的核心在於一個簡單而強大的概念：在由Try結構封裝的包裝值通道上進行操作。

此類通道可以手動建立，
也可以透過FromSlice或FromChan等實用程式建立，
然後透過Map、Filter、FlatMap等操作進行轉換。
最後，當所有處理階段完成後，可以透過ForEach、ToSlice或透過迭代結果通道來手動消耗資料。

背景上下文
需要執行任何特殊操作即可使用 Go 併發性。大多數人編寫 HTTP 服務，每個請求都已經在單獨的 goroutine 中處理。您只需要確保您使用的所有其他庫都是執行緒安全的，並且在大多數情況下，它們都是執行緒安全的。

當需要實現批處理以減少資料庫負載時，高階併發問題就發生了：

批次 DB 插入：多個執行程式處理 DB 插入。將記錄收集到一個通道，然後處理該通道，分批插入。
批處理資料庫更新：與插入類似，但用於更新，如 UPDATE users SET last_active_at=NOW() WHERE id IN(?,?,?,?..)
批次處理佇列資訊：收集一批訊息，提取 ID，並執行一次資料庫查詢 WHERE id IN (...) ，然後將訊息標記為已處理。

還有更多情況，不僅與 DB 有關。我很快意識到，我不想一遍又一遍地重複同樣的程式碼，所以我做了一個泛型批處理函式。那時候 Go 還沒有泛型，所以我的泛型函式實際上是基於反射的。

編寫基本的並行迴圈讓我瞭解了 WaitGroups，
而與錯誤處理相關的一些 bug 和 goroutine 洩露則讓我瞭解了 ErrGroup。

有一次，我需要一個可以容納多達 N 個唯一鍵的對映。嘗試插入 N+1 個鍵時會阻塞，直到另一個鍵被刪除。為了實現這個目標，我學習了 sync.Condition。

我還需要下載許多巨大的 CSV 檔案，每個檔案都包含特定日期的交易列表。之後，我需要解析和比較連續幾天的 CSV。為了加快速度，我需要同時下載它們。這就是我的 Rill 模組中 Ordered* 函式的誕生過程。

同步包並沒有錯，在某些情況下，同步/原子是解決問題的最佳方法。

Rill主要特徵

輕量級：快速且模組化，可以輕鬆整合到現有專案中
易於使用：管理 goroutine、等待組和錯誤處理的複雜性被抽象化了
Concurrent：控制所有操作的併發級別
批處理：提供了一種簡單的方式來批次組織和處理資料
錯誤處理：提供一種結構化的方法來處理併發應用程式中的錯誤
流：以最小的記憶體佔用處理實時資料流或大型資料集
順序保留：提供保留資料原始順序的功能，同時仍然允許併發處理
高效的資源使用：goroutines 的數量和分配不取決於資料大小
通用：所有操作都是型別安全的，可以與任何資料型別一起使用
函數語言程式設計：基於函數語言程式設計概念，使map、filter、flatMap等操作可用於基於通道的工作流程

用法示例
考慮一個從多個 URL 獲取鍵、從鍵值資料庫批次檢索其值並列印它們的應用程式。此示例展示了該庫在處理併發任務、錯誤傳播、批處理和資料流方面的優勢，同時保持簡單性和效率。

func main() {
    urls := rill.FromSlice([]string{
        <font>"https://example.com/file1.txt",
        "https://example.com/file2.txt",
        "https://example.com/file3.txt",
        "https://example.com/file4.txt",
    }, nil)

    // 從每個 URL 獲取鍵值，並將其扁平化為單一流<i>
    keys := rill.FlatMap(urls, 3, func(url string) <-chan rill.Try[string] {
        return streamFileLines(url)
    })

    // 從資料流中排除任何空鍵<i>
    keys = rill.Filter(keys, 3, func(key string) (bool, error) {
        return key != "", nil
    })

    //將金鑰key整理成易於管理的批次，每批 10 個，以便批次操作<i>
    keyBatches := rill.Batch(keys, 10, 1*time.Second)

    // 從資料庫中獲取每批鍵的值<i>
    resultBatches := rill.Map(keyBatches, 3, func(keys []string) ([]KV, error) {
        values, err := kvMultiGet(keys...)
        if err != nil {
            return nil, err
        }

        results := make([]KV, len(keys))
        for i, key := range keys {
            results[i] = KV{Key: key, Value: values[i]}
        }

        return results, nil
    })

    //將批次轉換回單個專案進行最終處理<i>
    results := rill.Unbatch(resultBatches)

    //從資料流中排除任何空值<i>
    results = rill.Filter(results, 3, func(kv KV) (bool, error) {
        return kv.Value != "<nil>", nil
    })

    //遍歷每個鍵值對並列印<i>
    cnt := 0
    err := rill.ForEach(results, 1, func(kv KV) error {
        fmt.Println(kv.Key, "=>", kv.Value)
        cnt++
        return nil
    })
    if err != nil {
        fmt.Println("Error:", err)
    }

    fmt.Println("Total keys:", cnt)
}

// streamFileLines 可以從 URL 逐行流式傳輸檔案、<i>
func streamFileLines(url string) <-chan rill.Try[string] {
    // ...<i>
}

// kvMultiGet 從鍵值資料庫中進行批次讀取、<i>
func kvMultiGet(keys ...string) ([]string, error) {
    // ...<i>
}

批處理
批處理是併發處理中的常見模式，尤其是在處理外部服務或資料庫時。 Rill 提供了Batch函式，可將專案流組織成指定大小的批次。還可以指定一個超時，之後即使批次未滿，也會發出該批次。當輸入流緩慢或稀疏時，這對於保持應用程式的反應非常有用。

扇入和扇出
提供了扇入和扇出資料流的機制。扇入是透過合併功能完成的，該功能將多個資料流合併到一個統一的通道中。扇出是透過Split2函式完成的，該函式將單個輸入流劃分為兩個不同的輸出通道。這種劃分基於鑑別器函式，允許基於資料特徵的並行處理路徑。

錯誤處理
錯誤是使用ForEach處理的，這對於大多數用例都有好處。 ForEach在出現第一個錯誤時停止處理並返回該錯誤。如果您需要在管道中間處理錯誤，和/或在發生錯誤後繼續處理，可以使用Catch函式。

終止和資源洩漏
在 Go 併發應用程式中，如果一個通道沒有讀者，那麼寫者就會被卡住，從而導致潛在的程式和記憶體洩漏。

這個問題也會延伸到基於 Go 通道構建的 rill 管道；如果管道中的任何階段缺少消費者，上游的整個生產者鏈都可能被阻塞。

因此，確保管道被完全消費至關重要，尤其是在錯誤導致提前終止的情況下。

下面的示例演示了一種情況，即最後處理階段在第一次遇到錯誤時退出，從而導致管道處於阻塞狀態。

func doWork(ctx context.Context) error {
    <font>// 初始化管道的第一階段<i>
    ids := streamIDs(ctx)
    
    // Define other pipeline stages...<i>
    
    // 最後階段處理<i>
    for value := range results {
        // Process value...<i>
        if someCondition {
            return fmt.Errorf("some error") // Early exit on error<i>
        }
    }
    return nil
}

為防止出現此類問題，建議確保在出現錯誤時排空結果通道。一種直接的方法是使用 defer 來呼叫 DrainNB：

func doWork(ctx context.Context) error {
    <font>// Initialize the first stage of the pipeline<i>
    ids := streamIDs(ctx)
    
    // Define other pipeline stages...<i>
    
    // 確保在發生故障時排空管道<i>
    defer rill.DrainNB(results)
    
    // Final stage processing<i>
    for value := range results {
        // Process value...<i>
        if someCondition {
            return fmt.Errorf("some error") // Early exit on error<i>
        }
    }
    return nil
}

利用 ForEach 或 ToSlice 等內建排水機制的函式，可以簡化程式碼並提高可讀性：

func doWork(ctx context.Context) error {
    <font>// Initialize the first stage of the pipeline<i>
    ids := streamIDs(ctx)
    
    // Define other pipeline stages...<i>

    // Final stage processing<i>
    return rill.ForEach(results, 5, func(value string) error {
        // Process value...<i>
        if someCondition {
            return fmt.Errorf("some error") // 出錯時提前退出，自動排水<i>
        }
        return nil
    })
}

雖然這些措施能有效防止洩漏，但只要初始階段產生數值，管道就可能繼續在後臺消耗數值。

最佳做法是使用上下文管理第一階段（以及可能的其他階段），從而實現受控關閉：

func doWork(ctx context.Context) error {
    ctx, cancel := context.WithCancel(ctx)
    defer cancel() <font>// 確保功能退出時取消第一階段<i>

    // Initialize the first stage of the pipeline<i>
    ids := streamIDs(ctx)

    // Define other pipeline stages...<i>

    // Final stage processing<i>
    return rill.ForEach(results, 5, func(value string) error {
        // Process value<i>
        if someCondition {
            return fmt.Errorf("some error") // Early exit on error, with automatic draining<i>
        }
        return nil
    })
}

順序保持
在併發環境中，由於並行執行的特性，保持已處理專案的原始順序具有挑戰性。當數值從輸入通道讀取、透過函式 f 處理並寫入輸出通道時，它們的順序可能與輸入順序不一致。為了解決這個問題，rill 為其核心函式（如 OrderedMap、OrderedFilter 等）提供了有序版本。這些函式確保，如果輸入通道中的值 x 在值 y 之前，那麼輸出中的 f(x) 就會在 f(y) 之前，從而保持原來的順序。值得注意的是，與無序函式相比，這些有序函式會產生少量開銷，這是因為需要額外的邏輯來保持順序。

在資料順序會影響結果的情況下，保持順序至關重要。例如，一個應用程式需要檢索特定時間段內的每日溫度測量值，並計算一天到第二天的溫度變化。雖然並行獲取資料可以提高效率，但按照原始順序處理資料對於準確計算溫度變化至關重要。

type Measurement struct {
    Date time.Time
    Temp float64
}

func main() {
    city := <font>"New York"
    endDate := time.Now()
    startDate := endDate.AddDate(0, 0, -30)

    // 建立一個通道，傳送開始日期和結束日期之間的所有天數<i>
    days := make(chan rill.Try[time.Time])
    go func() {
        defer close(days)
        for date := startDate; date.Before(endDate); date = date.AddDate(0, 0, 1) {
            days <- rill.Wrap(date, nil)
        }
    }()

    // 同時下載每天的溫度<i>
    measurements := rill.OrderedMap(days, 10, func(date time.Time) (Measurement, error) {
        temp, err := getTemperature(city, date)
        return Measurement{Date: date, Temp: temp}, err
    })

    // 迭代測量結果，計算並列印變化。使用單個 goroutine<i>
    prev := Measurement{Temp: math.NaN()}
    err := rill.ForEach(measurements, 1, func(m Measurement) error {
        change := m.Temp - prev.Temp
        prev = m

        fmt.Printf("%s: %.1f°C (change %+.1f°C)\n", m.Date.Format("2006-01-02"), m.Temp, change)
        return nil
    })
    if err != nil {
        fmt.Println("Error:", err)
    }
}

// getTemperature 獲取城市和日期的溫度讀數<i>
func getTemperature(city string, date time.Time) (float64, error) {
    // ...<i>
}

Rill：Go語言中併發+事務的批處理開源專案

相關文章