List of Context [text.Baldanders.info]

time.Ticker で遊ぶ【Go 1.16 バージョン】

2021-02-18T12:34:25+00:00

ずいぶん前に「time.Ticker で遊ぶ」と言う記事を書いたのだが，先日リリースされた Go 1.16 で signal.NotifyContext() 関数が追加された記念に，これを使った改訂版の記事を書いてみたいと思う。

前回と同じくお題は以下の通り。

一定周期ごとの処理を行う
Ctrl+C 等の割り込み処理を行う

一定周期ごとの処理を行う

これは前回の記事をほぼそのまま使いまわそう。

// +build run

package main

import (
    "fmt"
    "time"
)

func ticker() {
    t := time.NewTicker(1 * time.Second) //1秒周期の ticker
    defer func() {
        fmt.Println("Stopping ticker...")
        t.Stop()
    }()

    for {
        select {
        case now := <-t.C:
            fmt.Println(now.Format(time.RFC3339))
        }
    }
}

func main() {
    ticker()
}

前回でも説明した通り， defer 構文を使って終了時に time.Ticker.Stop() 関数で周期イベントを止めようとしているが，実際には無限ループなので return まで到達しない（笑）

NotifyContext 関数で SIGNAL を捕まえる

Go では SIGINT や SIGTERM といった OS から送信される SIGNAL をイベントとして channel に送り込む仕掛けがある（ちなみに Ctrl+C は SIGINT として送られる）。さらに Go 1.16 では SIGNAL イベントを context.Context のキャンセル・イベントとして実装できるようになった。

たとえば，こんな感じに書ける。

// +build run

package main

import (
    "context"
    "fmt"
    "os"
    "os/signal"
    "time"
)

func ticker(ctx context.Context) {
    t := time.NewTicker(1 * time.Second) //1秒周期の ticker
    defer func() {
        fmt.Println("Stopping ticker...")
        t.Stop()
    }()

    for {
        select {
        case now := <-t.C:
            fmt.Println(now.Format(time.RFC3339))
        case <-ctx.Done():
            fmt.Println("cancellation from context:", ctx.Err())
            return
        }
    }
}

func run() {
    ctx, _ := signal.NotifyContext(context.Background(), os.Interrupt)
    ticker(ctx)
}

func main() {
    run()
}

context パッケージは並行処理下で使うことが多いだろう。たとえば run() 関数をこんな感じに書き換えてみるか。

func run() {
    ctx, _ := signal.NotifyContext(context.Background(), os.Interrupt)
    var wg sync.WaitGroup
    for i := 0; i < 3; i++ {
        n := i + 1
        wg.Add(1)
        go func() {
            defer wg.Done()
            ticker(ctx, n)
        }()
    }
    wg.Wait()
}

これで平行に動作している全ての ticker() に対してキャンセルを送り込むことができる。

上のコード例ではひとつの context.Context インスタンスを複数の goroutine で使いまわしているが，以下のように

func run() {
    var wg sync.WaitGroup
    for i := 0; i < 3; i++ {
        n := i + 1
        wg.Add(1)
        go func() {
            defer wg.Done()
            ctx, _ := signal.NotifyContext(context.Background(), os.Interrupt)
            ticker(ctx, n)
        }()
    }
    wg.Wait()
}

各 goroutine ごとに context.Context インスタンスを生成してセットしても全ての ticker() を Ctrl+C で問題なく止めることができた。

キャンセル・イベントの伝搬

context パッケージは，名前の通り，異なるレイヤやドメイン間でコンテキスト情報を受け渡しするためのパッケージだが，親から子にキャンセルイベントが伝搬する性質がある（逆向きには伝搬しない）。たとえば

func run() {
    parent, _ := signal.NotifyContext(context.Background(), os.Interrupt)
    var wg sync.WaitGroup
    for i := 0; i < 3; i++ {
        n := i + 1
        wg.Add(1)
        go func() {
            defer wg.Done()
            child, _ := context.WithTimeout(parent, time.Duration(n)*5*time.Second)
            ticker(child, n)
        }()
    }
    wg.Wait()
}

などとすれば各 goroutine の ticker() 関数に SIGNAL イベントとタイムアウト・イベントの両方を仕込むことができる。

また

ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt)

とした場合の返り値の cancel は関数値になっていて，これをキックすることでペアとなっている context.Context インスタンス（上のコードなら ctx）にキャンセル・イベントを発生させることができる。実際の使い方として signal.NotifyContext() 関数は main goroutine に近いところで context.WithCancel() 関数と置き換えることが多いのではないだろうか。

context について詳しくは『Go 言語による並行処理』の 4.12 章が参考になる。素敵なキャンセル・ライフを（笑）

ブックマーク

Big Sky :: os/signal に NotifyContext が入った。

参考図書

Go言語による並行処理: Katherine Cox-Buday (著), 山口能迪 (翻訳); オライリージャパン 2018-10-26; 単行本（ソフトカバー）; 4873118468 (ASIN), 9784873118468 (EAN), 4873118468 (ISBN); 評価

Eブック版もある。感想はこちら。 Go 言語で並行処理を書くならこの本は必読書になるだろう。

reviewed by Spiegel on 2020-01-13 (powered by PA-APIv5)

プログラミング言語Go (ADDISON-WESLEY PROFESSIONAL COMPUTING SERIES): Alan A.A. Donovan (著), Brian W. Kernighan (著), 柴田芳樹 (翻訳); 丸善出版 2016-06-20; 単行本（ソフトカバー）; 4621300253 (ASIN), 9784621300251 (EAN), 4621300253 (ISBN); 評価

著者のひとりは（あの「バイブル」とも呼ばれる）通称 “K&R” の K のほうである。この本は Go 言語の教科書と言ってもいいだろう。と思ったら絶版状態らしい（2025-01 現在）。復刊を望む！

reviewed by Spiegel on 2016-07-13 (powered by PA-APIv5)

『Go 言語による並行処理』は Go 言語プログラマ必読書だろう

2018-11-03T00:50:43+00:00

やぁ！ついに “Concurrency in Go” の邦訳版が登場したですよ。めでたい！

Go 言語の特徴はいくつかあるが，大きなものとして「並行処理¹」を前提とした言語設計が挙げられる。

並行処理では CSP (Communicating Sequential Processes) の成果が取り入れられている。これが goroutine と channel である。

Goroutine は軽量スレッドなどと呼ばれることもあるが²，厳密には coroutine の一種である。 Main goroutine を含む各 goroutine はランタイム・プログラムに組み込まれたスケジューラによって制御される。つまり実行時の並列処理の詳細はコードレベルでは隠蔽されているのだ。故にプログラマはコード上の並行処理にのみ注力して記述すればいいことになる。 OS スレッドの仕様がどうなってるとか無駄にデカいスレッドをプールの中でどう使い回すかとか，生産性の欠片もないようなことは考えなくていいわけだ³。

Channel は入出力プリミティブで，これによって goroutine 間のメッセージ・パッシング（message passing）を実現している。たとえば以下のような感じで記述する⁴。

package main

import "fmt"

//main goroutine
func main() {
    hello := make(chan interface{}) //create channel
    go func() { //sub goroutine
        hello <- "Hello, world!" //send
    }()
    fmt.Println(<-hello) //receive
}

（go 構文（go statement）でキックされた関数が sub goroutine となる。関数閉包（closure）になっている点に注目）

これらに加えて，同期をとるための sync パッケージやコールグラフの各枝をキャンセルするための context パッケージが標準ライブラリで用意されている。

メッセージ・パッシングを構成するか sync パッケージ等を用いて legacy なメモリアクセス同期を構成するか（あるいはそれらを組み合わせるか）の判断は難しいが，2.4章に大まかな指針が挙げられているので参考になるだろう。ただし，今まで無理やりメモリアクセス同期で運用していたもののうちかなりのものを軽くて（スレッドセーフという意味で）安全なメッセージ・パッシングに置き換えられるのは確かである。

そうそう。『Go 言語による並行処理』では context パッケージについてページを割いて紹介されているのだ⁵（4.12章）。 context パッケージをデザイン・パターンとして日本語できちんと紹介している Web 記事や書籍はあまり見かけないので，単純に嬉しい。

並行処理プログラミングが難しいのは，デザイン・パターン（4章で言及されている）の熟成がまだ若いこと，パターンの組み合わせ最適化が複雑なこと，もっと言うなら並行処理の設計は context driven であること，にあると思う（だからこそ context パッケージは秀逸なのよ）。デザイン・パターンは（数学の公式と同じく）思考のショートカットなので，そのパターンを構成することの意味を分かった上で適用しないと失敗することが多いんじゃないだろうか。

この本を読んで「よっしゃ，明日から立派な goroutine 使いだ！」とはならないと思うけど，有象無象なコピペ・プログラマじゃなく，きちんと Go 言語のプログラミングを勉強したいのであれば，この本は必読書になると思う。少なくとも（立ち読みででも）2章までは熟読すべき。

ところで余談だが，補遺Bは日本語版オリジナルの章だそうだけど，その中に Go 2 ドラフトで提案されている Generics についてしれっと書かれている。

Go 2 Drafts Announcement - YouTubeより

次期 Go 言語に搭載される（かもしれない） Generics についての解説は以下を参考にどうぞ。

Go 2のgenerics/contract簡易まとめ

ブックマーク

参考図書

Go言語による並行処理: Katherine Cox-Buday (著), 山口能迪 (翻訳); オライリージャパン 2018-10-26; 単行本（ソフトカバー）; 4873118468 (ASIN), 9784873118468 (EAN), 4873118468 (ISBN); 評価

Eブック版もある。感想はこちら。 Go 言語で並行処理を書くならこの本は必読書になるだろう。

reviewed by Spiegel on 2020-01-13 (powered by PA-APIv5)

プログラミング言語Go (ADDISON-WESLEY PROFESSIONAL COMPUTING SERIES): Alan A.A. Donovan (著), Brian W. Kernighan (著), 柴田芳樹 (翻訳); 丸善出版 2016-06-20; 単行本（ソフトカバー）; 4621300253 (ASIN), 9784621300251 (EAN), 4621300253 (ISBN); 評価

reviewed by Spiegel on 2016-07-13 (powered by PA-APIv5)

「同時に複数の動作が行われていること」を意味する言葉として「並行（concurrent）」と「並列（parallel）」が混同されることがあるが，プログラミングにおいては，書かれたコードの性質をを表すものを「並行」，動作するランタイム・プログラム（群）の性質を表すものを「並列」と呼んで区別している。両者は密接に関連しているが等価ではない。 ↩︎
OS スレッドに比べて goroutine を駆動する（ランタイム・プログラムが展開する）グリーン・スレッドは非常に軽量らしい。初期のメモリ割当で数キロバイト程度で，実行時に自動的に増減するようだ。 Goroutine のリソースの概算については3.1章で言及されている。 ↩︎
ある規模以上のシステムの場合は流量制限等をかける必要があるかも知れない。大規模システム開発での注意点については5章で言及されている。 ↩︎
受信（<-chan）は単項演算子で，送信（chan<-）は送信構文（send statement）で記述する。 ↩︎
context パッケージはバージョン 1.7 から標準ライブラリに組み込まれたため，古い参考書には載っていない。なお context パッケージにはキャンセルの伝搬以外にもコールグラフ間でデータを受け渡す機能もある。もっともこちらは濫用するとヤバいけど。 ↩︎

time.Ticker で遊ぶ

2018-03-01T11:28:49+00:00

【2021-02-18】 Go 1.16 で追加された関数を使った「time.Ticker で遊ぶ【Go 1.16 バージョン】」を公開した。併せてどうぞ。

相変わらず小ネタで。今回の目標は2つ。

一定周期ごとの処理を行う
Ctrl+C 等の割り込み処理を行う

一定周期ごとの処理を行う

Go 言語で一定周期ごとに処理を行うには time.Ticker が使える。以下は1秒ごとに現在時刻を表示する処理である。

package main

import (
	"fmt"
	"time"
)

func ticker() {
	t := time.NewTicker(1 * time.Second) //1秒周期の ticker
	defer t.Stop()

	for {
		select {
		case now := <-t.C:
			fmt.Println(now.Format(time.RFC3339))
		}
	}
}

func main() {
	ticker()
}

time.Ticker.C は受信 channel で，周期イベント発生時の時刻がセットされる。 defer 構文を使って終了時に time.Ticker.Stop() 関数で周期イベントを止めようとしているが，実際には無限ループなので， return まで到達しない（笑）

このコードはちゃんと動くが，終了条件を記述していないので Ctrl+C などで外部から強制的に止めない限り動き続ける。

SIGNAL を捕まえる

Go 言語では SIGINT や SIGTERM といった OS から送信される SIGNAL をイベントとして channel に送り込む仕掛けがある（ちなみに Ctrl+C は SIGINT として送られる）。この仕掛けを組み込んだコードが以下である。

package main

import (
	"fmt"
	"os"
	"os/signal"
	"syscall"
	"time"
)

func ticker() {
	t := time.NewTicker(1 * time.Second) //1秒周期の ticker
	defer t.Stop()

	sig := make(chan os.Signal, 1)
	signal.Notify(sig,
		syscall.SIGHUP,
		syscall.SIGINT,
		syscall.SIGTERM,
		syscall.SIGQUIT,
	)
    defer signal.Stop(sig)

	for {
		select {
		case now := <-t.C:
			fmt.Println(now.Format(time.RFC3339))
		case s := <-sig:
			switch s {
			case syscall.SIGHUP, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT:
				fmt.Println("Stop!")
				return
			}
		}
	}
}

func main() {
	ticker()
}

このやり方であれば Ctrl+C でも強制終了することなく正しく time.Ticker.Stop() 関数が起動される。

ここまでが main goroutine のみの処理の場合。複数の goroutine が協調して動いている場合は SIGNAL イベントに対して全ての goroutine が適切に処理を行う必要がある。

キャンセル・イベントの伝搬

Go 言語 1.7 から context が標準パッケージに加わった。 context パッケージは，名前の通り，異なるレイヤやドメイン間でコンテキスト情報を受け渡しするためのパッケージだが，キャンセル・イベントを扱うことができる。

ctx := context.Background()
parent, cancelParent := context.WithCancel(ctx)
child, cancelChild := context.WithCancel(parent)

cancelParent および cancelChild は関数値で，これをキックすることでそれぞれの context.Context にキャンセル・イベントが発生する。面白いのは parent で発生したイベントは child にも伝搬する点である（逆向きには伝搬しない）。これを利用して，発生した SIGNAL に対して親の context.Context にイベントを発生させることによって全ての子 context.Context にイベントを伝搬させることが可能になる。

たとえば，先ほどの SIGNAL の処理は以下のように書き直すことができる。

func SignalContext(ctx context.Context) context.Context {
	parent, cancelParent := context.WithCancel(ctx)
	go func() {
		defer cancelParent()

		sig := make(chan os.Signal, 1)
		signal.Notify(sig,
			syscall.SIGHUP,
			syscall.SIGINT,
			syscall.SIGTERM,
			syscall.SIGQUIT,
		)
        defer signal.Stop(sig)

		select {
		case <-parent.Done():
			fmt.Println("Cancel from parent")
			return
		case s := <-sig:
			switch s {
			case syscall.SIGHUP, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT:
				fmt.Println("Stop!")
				return
			}
		}
	}()

	return parent
}

ticker() 関数のほうも context.Context のイベントを拾えるよう以下のように書き直す。

func ticker(ctx context.Context) error {
	t := time.NewTicker(1 * time.Second) //1秒周期の ticker
	defer t.Stop()

	for {
		select {
		case now := <-t.C:
			fmt.Println(now.Format(time.RFC3339))
		case <-ctx.Done():
			fmt.Println("Stop child")
			return ctx.Err()
		}
	}
}

周期処理と SIGNAL 受信処理を別々の goroutine で駆動させて両者を context.Context で繋ぐのである。

完全なコードは以下の通り。

package main

import (
	"context"
	"fmt"
	"os"
	"os/signal"
	"syscall"
	"time"
)

func ticker(ctx context.Context) error {
	t := time.NewTicker(1 * time.Second) //1秒周期の ticker
	defer t.Stop()

	for {
		select {
		case now := <-t.C:
			fmt.Println(now.Format(time.RFC3339))
		case <-ctx.Done():
			fmt.Println("Stop child")
			return ctx.Err()
		}
	}
}

func SignalContext(ctx context.Context) context.Context {
	parent, cancelParent := context.WithCancel(ctx)
	go func() {
		defer cancelParent()

		sig := make(chan os.Signal, 1)
		signal.Notify(sig,
			syscall.SIGHUP,
			syscall.SIGINT,
			syscall.SIGTERM,
			syscall.SIGQUIT,
		)
        defer signal.Stop(sig)

		select {
		case <-parent.Done():
			fmt.Println("Cancel from parent")
			return
		case s := <-sig:
			switch s {
			case syscall.SIGHUP, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT:
				fmt.Println("Stop!")
				return
			}
		}
	}()

	return parent
}

func Run(ctx context.Context) error {
	errCh := make(chan error, 1)
	defer close(errCh)

	parent := SignalContext(ctx)
	go func() {
		child, cancelChild := context.WithTimeout(parent, 10*time.Second)
		defer cancelChild()
		errCh <- ticker(child)
	}()

	err := <-errCh
	fmt.Println("Done parent")
	return err
}

func main() {
	ctx := context.Background()
	if err := Run(ctx); err != nil {
		fmt.Fprintln(os.Stderr, err)
		return
	}
	fmt.Println("Done")
}

ちなみに context.WithTimeout() 関数は context.Context にタイムアウト・イベントを付加する。他にもデッドライン日時を指定する context.WithDeadline() 関数がある。

なんか今回は久しぶりに Go 言語っぽいコードだったねぇ（笑）

【追記】 Windows では SIGNAL を送信できない

今回は SIGNAL を受信する場合の話だったが，もちろん任意のプロセスに SIGNAL を送信することもできる。以下は自分自身に SIGINT を投げるコード例である¹。

proc, _ := os.FindProcess(os.Getppid())
proc.Signal(os.Interrupt)

ただし，このコードは Windows では（コンパイル・エラーにはならないが）動かない。 Windows 用の os.Process.Signal() 関数の実体は以下の通りだが

func (p *Process) signal(sig Signal) error {
	handle := atomic.LoadUintptr(&p.handle)
	if handle == uintptr(syscall.InvalidHandle) {
		return syscall.EINVAL
	}
	if p.done() {
		return errors.New("os: process already finished")
	}
	if sig == Kill {
		err := terminateProcess(p.Pid, 1)
		runtime.KeepAlive(p)
		return err
	}
	// TODO(rsc): Handle Interrupt too?
	return syscall.Errno(syscall.EWINDOWS)
}

このように os.Kill (SIGKILL) 以外は効かないようになっている。理由は不明だが TODO になってるようなので何か理由があるのだろう。

というわけでテストができないのですよ orz

ブックマーク

参考図書

プログラミング言語Go (ADDISON-WESLEY PROFESSIONAL COMPUTING SERIES): Alan A.A. Donovan (著), Brian W. Kernighan (著), 柴田芳樹 (翻訳); 丸善出版 2016-06-20; 単行本（ソフトカバー）; 4621300253 (ASIN), 9784621300251 (EAN), 4621300253 (ISBN); 評価

reviewed by Spiegel on 2016-07-13 (powered by PA-APIv5)

syscall パッケージを使うやり方もあるが，今回は割愛する。つか， Windows 版には syscall.Kill() 関数が存在しないのでやりようがないのだが。 ↩︎