package main

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

func main() {
	// 1 秒に 1 回起動する ticker を作成する
	// 具体的には Ticker.C という chan Time なチャンネルに指定間隔で変数が投げられるようになります
	ticker := time.NewTicker(1 * time.Second)

	// 終了処理用に bool 型のチャンネルを用意する
	done := make(chan bool, 1)

	// シグナル受信用のチャンネルを用意する
	sigs := make(chan os.Signal, 1)

	// プログラムがシグナルを受信した際に、チャンネルに通知するように設定する
	// 具体的には `os.Interrupt` (SIGINT のこと) をプログラムが受信したら
	// sigs 変数のチャンネルに通知するように設定しています
	signal.Notify(sigs, os.Interrupt)

	cnt := 0

	// 以下の関数を、goroutine として非同期に実行開始する
	go func() {
		for {
			// ticker.C チャンネルに何か来るまで for ループを止める
			// ticker のところでも解説しましたが、1 秒に1回、Time 型の変数が投げられます
			<-ticker.C
			cnt += 1
			fmt.Println(cnt)
		}
	}()

	// 以下の関数を、goroutine として非同期に実行開始する
	go func() {
		// sigs チャンネルに何かが来るまで goroutine を止める
		<-sigs

		// 標準出力に "bye" と表示する
		fmt.Println("bye")

		// 後始末として ticker を止める
		ticker.Stop()

		// done チャンネルに true を投げる
		done <- true
	}()

	// done チャンネルに何かが来るまでプログラムを止める
	<-done
}

$ go run main.go

type Signal interface {
	String() string
	Signal() // 他の Stringer な interface と区別するためのダミー用定義なので使わない
}

var (
	Interrupt Signal = syscall.SIGINT
	Kill Signal      = syscall.SIGKILL
)

sigs := make(chan os.Signal, 1)
signal.Notify(sigs) // すべてのシグナルが sigs に流れるようになる

package main

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

func main() {
	done := make(chan bool, 1)
	s1 := make(chan os.Signal, 1)
	s2 := make(chan os.Signal, 1)

	go func() {
		<-s1
		fmt.Println("got s1")
		done <- true
	}()
	go func() {
		<-s2
		fmt.Println("got s2")
		done <- true
	}()

	signal.Notify(s1, os.Interrupt)

	<-done

	signal.Notify(s2, os.Interrupt)

	<-done
}

package main

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

func main() {
	// 復帰できるように 10 秒タイマーを作っておきます。
	t := time.NewTimer(10 * time.Second)
	sigs := make(chan os.Signal, 1)

	fmt.Println("ignore Ctrl + C")

	// Ignonre を呼び出し、 Ctrl + C を無視させます
	signal.Ignore(os.Interrupt)

	go func() {
		// 10 秒経過後、Ctrl + C を受け取れるようにします
		<-t.C
		t.Stop()

		fmt.Println("start to accept Ctrl + c")
		signal.Notify(sigs, os.Interrupt)
	}()

	<-sigs
	fmt.Println("bye")
}

$ go run main.go
ignore Ctrl + C

start to accept Ctrl + c
^Cbye

package main

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

func main() {
	tm := time.NewTimer(10 * time.Second)
	ti := time.NewTicker(1 * time.Second)
	sigs := make(chan os.Signal, 1)

	fmt.Println("ignore Ctrl + C")
	signal.Ignore(os.Interrupt)

	go func() {
		for {
			<-ti.C
			if signal.Ignored(os.Interrupt) {
				fmt.Println("ignoring Ctrl + C")
			} else {
				fmt.Println("wait Ctrl + C")
			}
		}
	}()

	go func() {
		<-tm.C
		tm.Stop()

		fmt.Println("start to accept Ctrl + c")
		signal.Notify(sigs, os.Interrupt)
	}()

	<-sigs
	ti.Stop()
	fmt.Println("bye")
}

$ go run main.go
ignore Ctrl + C
ignoring Ctrl + C
ignoring Ctrl + C
ignoring Ctrl + C
ignoring Ctrl + C
ignoring Ctrl + C
ignoring Ctrl + C
ignoring Ctrl + C
ignoring Ctrl + C
ignoring Ctrl + C
ignoring Ctrl + C
start to accept Ctrl + c
wait Ctrl + C
wait Ctrl + C
wait Ctrl + C
^Cbye

package main

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

func main() {
	parent, cancel := context.WithCancel(context.Background())

	ctx, stop := signal.NotifyContext(parent, os.Interrupt)
	defer stop()

	go func(ctx context.Context) {
		// 親から context 受け取ってるけど特にすることないので無視
		// 本当は 親 context が終了した時の処理書いたほうがいいです

		for {
			var in string
			fmt.Scanln(&in)
			fmt.Println(in)
			switch in {
			case "cancel":
				fmt.Println("canceled")
				cancel()
			case "exit":
				fmt.Println("exited")
				stop()
			default:
				fmt.Println(in)
			}
		}
	}(ctx)

	select {
	case <-time.After(10 * time.Second):
		fmt.Println("time out")
	case <-ctx.Done():
		stop()
		fmt.Println("interuppted")
	}
}

package main

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

func main() {
	ticker := time.NewTicker(1 * time.Second)

	done := make(chan bool, 1)
	sigs := make(chan os.Signal, 1)

	// プログラムが Ctrl + C を受信した際に、チャンネルに通知するように設定する
	signal.Notify(sigs, os.Interrupt)

	cnt := 0

	go func() {
		for {
			<-ticker.C
			cnt += 1
			fmt.Println(cnt)
		}
	}()

	// Ctrl + C をこのプログラムで処理しないようにする　
	signal.Reset(os.Interrupt)

	go func() {
		// sigs チャンネルが Ctrl + C を受信することがないので、以下のステップには到達しなくなります
		<-sigs
		fmt.Println("bye")
		ticker.Stop()
		done <- true
	}()

	<-done
}

$ go run main.go
^Csignal: interrupt

package main

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

func main() {
	ticker := time.NewTicker(1 * time.Second)

	done := make(chan bool, 1)
	sigs := make(chan os.Signal, 1)

	signal.Notify(sigs, os.Interrupt)

	cnt := 0

	go func() {
		for {
			<-ticker.C
			cnt += 1
			fmt.Println(cnt)
		}
	}()

	// sigs チャンネルでシグナルを受信するのを停止する
	signal.Stop(sigs)

	go func() {
		// sigs チャンネルが Ctrl + C を受信することがないので、以下のステップには到達しなくなります
		<-sigs
		fmt.Println("bye")
		ticker.Stop()
		done <- true
	}()

	<-done
}

$ go run main.go
^Csignal: interrupt