kubernetes 依賴庫apimachinery中的 wait 庫功能（1）

該庫提供了很多基於週期性執行的方法，以及約束週期性執行的方法。

週期性執行一個函式

在某些情況下，我們需要週期性地執行一些動作，比如傳送心跳請求給 master，那麼可以使用 wait 庫中的 Forever 功能。 這裡給一個簡單的例子，每隔一秒鐘輸出當前的時間。

package main

import (
    "fmt"
    "time"

    "k8s.io/apimachinery/pkg/util/wait"
)

func main() {
    wait.Forever(func() {
        fmt.Println(time.Now().String())
    }, time.Second)
}

帶 StopSignal 的週期性執行函式

上面的 Wait 函式其實是 Util 的變體，Util 本身還帶有一個 stopSignal 選項。比如我們要刪除一個 CDN 資源，然後刪除之後週期性地檢查檔案是否還可以訪問。可以用下面的邏輯。我們這裡用 counter 來代替檢查資源狀態的判斷邏輯。

package main

import (
    "fmt"
    "time"

    "k8s.io/apimachinery/pkg/util/wait"
)

var stopSignal = make(chan struct{})

func main() {
    var counter = 1
    wait.Until(func() {
        if counter > 10 {
            close(stopSignal)
        }
        fmt.Println(time.Now().String())
        counter++
    }, time.Second, stopSignal)

}

sync.WaitGroup 的封裝及擴充套件

最簡單的是對 WaitGroup 的簡單封裝

package main

import (
    "fmt"

    "k8s.io/apimachinery/pkg/util/wait"
)

func main() {
    g := wait.Group{}
    for i := 0; i < 100; i++ {
        j := i
        g.Start(func() {
            fmt.Println(j)
        })
    }
    g.Wait()
}

我們再假設一個場景，老大說大家去抓網頁，差不多抓滿 1000 個網頁就結束。這個時候大家併發去抓，想要同步是比較困難的，另外什麼時候通知大家結束也比較麻煩。這裡，我們可以用下面的這樣的框架程式碼。

package main

import (
    "fmt"
    "time"

    "sync/atomic"

    "k8s.io/apimachinery/pkg/util/wait"
)

var stopSignal = make(chan struct{})

func main() {
    g := wait.Group{}
    var counter int32
    for i := 0; i < 100; i++ {
        j := i
        g.StartWithChannel(stopSignal, func(stopCh <-chan struct{}) {
            for {
                //quit if
                if atomic.LoadInt32(&counter) > 1000 {
                    return
                }
                //otherwise
                select {
                case <-stopSignal:
                    return
                default:
                    fmt.Println(j, time.Now().String())
                    atomic.AddInt32(&counter, 1)
                    <-time.After(time.Second)
                }
            }
        })
    }
    g.Wait()
}

剛剛的場景還可以使用StartWithContext方法來實現。

package main

import (
    "context"
    "fmt"
    "time"

    "sync/atomic"

    "k8s.io/apimachinery/pkg/util/wait"
)

func main() {
    g := wait.Group{}
    var counter int32
    ctx, cancelFunc := context.WithCancel(context.Background())
    for i := 0; i < 100; i++ {
        j := i
        g.StartWithContext(ctx, func(ctx context.Context) {
            for {
                //quit if
                if atomic.LoadInt32(&counter) > 1000 {
                    cancelFunc() //fire cancel signal
                }
                //otherwise
                select {
                case <-ctx.Done(): //cancel signal received
                    return
                default:
                    fmt.Println(j, time.Now().String())
                    atomic.AddInt32(&counter, 1)
                    <-time.After(time.Second)
                }
            }
        })
    }
    g.Wait()
}