Merge pull request #869 from devlights/add-countdownlatch-example

Author: devlights

examples/singleapp/count_down_latch/Taskfile.yml

@@ -0,0 +1,8 @@
+# https://taskfile.dev
+
+version: '3'
+
+tasks:
+  default:
+    cmds:
+      - go run .

examples/singleapp/count_down_latch/countdownlatch.go

@@ -0,0 +1,80 @@
+package main
+
+import (
+	"sync"
+	"sync/atomic"
+)
+
+// CountdownLatch は、C#-のCountdownEventやJavaのCountDownLatchと同様の機能を提供する構造体です.
+type CountdownLatch struct {
+	count int32
+	mutex sync.Mutex
+	cond  *sync.Cond
+}
+
+// NewCountdownLatch は、指定されたカウント数でCountdownLatchを初期化します.
+func NewCountdownLatch(initialCount int) *CountdownLatch {
+	if initialCount < 0 {
+		panic("初期カウントは0以上である必要があります")
+	}
+
+	var (
+		ce CountdownLatch
+	)
+	ce.count = int32(initialCount)
+	ce.cond = sync.NewCond(&ce.mutex)
+
+	return &ce
+}
+
+// Signal は、カウントを1減らします.
+// 戻り値として、カウントダウンが満了したかどうかを返します.
+func (me *CountdownLatch) Signal() bool {
+	return me.SignalCount(1)
+}
+
+// SignalCount は、指定された数だけカウントを減らします.
+// 戻り値として、カウントダウンが満了したかどうかを返します.
+func (me *CountdownLatch) SignalCount(count int) bool {
+	if count <= 0 {
+		return false
+	}
+
+	me.mutex.Lock()
+	defer me.mutex.Unlock()
+
+	newCount := atomic.AddInt32(&me.count, -int32(count))
+	if newCount <= 0 {
+		me.cond.Broadcast()
+		return true
+	}
+
+	return false
+}
+
+// Wait は、カウントが0になるまでブロックします.
+func (me *CountdownLatch) Wait() {
+	me.mutex.Lock()
+	defer me.mutex.Unlock()
+
+	for atomic.LoadInt32(&me.count) > 0 {
+		me.cond.Wait()
+	}
+}
+
+// CurrentCount は、現在のカウント値を返します.
+func (me *CountdownLatch) CurrentCount() int {
+	return int(atomic.LoadInt32(&me.count))
+}
+
+// Reset は、カウントを指定された値にリセットします.
+func (me *CountdownLatch) Reset(count int) {
+	if count < 0 {
+		panic("リセットカウントは0以上である必要があります")
+	}
+
+	me.mutex.Lock()
+	defer me.mutex.Unlock()
+
+	atomic.StoreInt32(&me.count, int32(count))
+}

examples/singleapp/count_down_latch/main.go

@@ -0,0 +1,99 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"log"
+	"sync"
+	"time"
+)
+
+const (
+	MainTimeout = 20 * time.Second
+	ProcTimeout = 10 * time.Second
+)
+
+var (
+	ErrMainTooSlow = errors.New("(MAIN) TOO SLOW")
+	ErrProcTooSlow = errors.New("(PROC) TOO SLOW")
+)
+
+func init() {
+	log.SetFlags(0)
+}
+
+func main() {
+	var (
+		rootCtx          = context.Background()
+		mainCtx, mainCxl = context.WithTimeoutCause(rootCtx, MainTimeout, ErrMainTooSlow)
+		procCtx          = run(mainCtx)
+		err              error
+	)
+	defer mainCxl()
+
+	select {
+	case <-mainCtx.Done():
+		err = context.Cause(mainCtx)
+	case <-procCtx.Done():
+		if err = context.Cause(procCtx); errors.Is(err, context.Canceled) {
+			err = nil
+		}
+	}
+
+	if err != nil {
+		log.Fatal(err)
+	}
+}
+
+func run(pCtx context.Context) context.Context {
+	var (
+		ctx, cxl = context.WithCancelCause(pCtx)
+	)
+
+	go func() {
+		cxl(proc(ctx))
+	}()
+	go func() {
+		<-time.After(ProcTimeout)
+		cxl(ErrProcTooSlow)
+	}()
+
+	return ctx
+}
+
+func proc(_ context.Context) error {
+	const (
+		latchCount = 3
+	)
+	var (
+		ce = NewCountdownLatch(latchCount)
+		wg sync.WaitGroup
+	)
+
+	for range 2 {
+		ce.Reset(latchCount)
+
+		for i := range 5 {
+			wg.Add(1)
+			go func(i int) {
+				defer wg.Done()
+
+				log.Printf("[%2d] 待機開始", i)
+				ce.Wait()
+				log.Printf("[%2d] 待機解除", i)
+			}(i)
+		}
+
+		for range 3 {
+			<-time.After(time.Second)
+
+			log.Printf("現在のカウント: %d\n", ce.CurrentCount())
+			ce.Signal()
+		}
+
+		wg.Wait()
+		log.Println("-------------------------------------")
+	}
+
+	return nil
+}