biuaxia

package main  

import (  
	"fmt"  
	"sync"  

	"time"  
)  

var wg sync.WaitGroup  

// 初期の例  

func worker() {  
	for {  
		fmt.Println("worker")  
		time.Sleep(time.Second)  
	}  
	// 外部コマンドを受け取って終了する方法  
	wg.Done()  
}  

func main() {  
	wg.Add(1)  
	go worker()  
	// 子goroutineを優雅に終了させる方法  
	wg.Wait()  
	fmt.Println("over")  
}  

package main  

import (  
	"fmt"  
	"sync"  

	"time"  
)  

var wg sync.WaitGroup  
var exit bool  

// グローバル変数方式の問題点：  
// 1. グローバル変数を使用すると、パッケージ間で統一が難しい  
// 2. worker内でさらにgoroutineを起動すると、制御が難しくなる。  

func worker() {  
	for {  
		fmt.Println("worker")  
		time.Sleep(time.Second)  
		if exit {  
			break  
		}  
	}  
	wg.Done()  
}  

func main() {  
	wg.Add(1)  
	go worker()  
	time.Sleep(time.Second * 3) // プログラムが早く終了しないように3秒スリープ  
	exit = true                 // グローバル変数を変更して子goroutineを終了させる  
	wg.Wait()  
	fmt.Println("over")  
}  

package main  

import (  
	"fmt"  
	"sync"  

	"time"  
)  

var wg sync.WaitGroup  

// チャネル方式の問題点：  
// 1. グローバル変数を使用すると、パッケージ間での規範と統一が難しく、共用のチャネルを維持する必要がある  

func worker(exitChan chan struct{}) {  
LOOP:  
	for {  
		fmt.Println("worker")  
		time.Sleep(time.Second)  
		select {  
		case <-exitChan: // 上位からの通知を待つ  
			break LOOP  
		default:  
		}  
	}  
	wg.Done()  
}  

func main() {  
	var exitChan = make(chan struct{})  
	wg.Add(1)  
	go worker(exitChan)  
	time.Sleep(time.Second * 3) // プログラムが早く終了しないように3秒スリープ  
	exitChan <- struct{}{}      // 子goroutineに終了信号を送信  
	close(exitChan)  
	wg.Wait()  
	fmt.Println("over")  
}  

package main  

import (  
	"context"  
	"fmt"  
	"sync"  

	"time"  
)  

var wg sync.WaitGroup  

func worker(ctx context.Context) {  
LOOP:  
	for {  
		fmt.Println("worker")  
		time.Sleep(time.Second)  
		select {  
		case <-ctx.Done(): // 上位からの通知を待つ  
			break LOOP  
		default:  
		}  
	}  
	wg.Done()  
}  

func main() {  
	ctx, cancel := context.WithCancel(context.Background())  
	wg.Add(1)  
	go worker(ctx)  
	time.Sleep(time.Second * 3)  
	cancel() // 子goroutineに終了を通知  
	wg.Wait()  
	fmt.Println("over")  
}  

package main  

import (  
	"context"  
	"fmt"  
	"sync"  

	"time"  
)  

var wg sync.WaitGroup  

func worker(ctx context.Context) {  
	go worker2(ctx)  
LOOP:  
	for {  
		fmt.Println("worker")  
		time.Sleep(time.Second)  
		select {  
		case <-ctx.Done(): // 上位からの通知を待つ  
			break LOOP  
		default:  
		}  
	}  
	wg.Done()  
}  

func worker2(ctx context.Context) {  
LOOP:  
	for {  
		fmt.Println("worker2")  
		time.Sleep(time.Second)  
		select {  
		case <-ctx.Done(): // 上位からの通知を待つ  
			break LOOP  
		default:  
		}  
	}  
}  
func main() {  
	ctx, cancel := context.WithCancel(context.Background())  
	wg.Add(1)  
	go worker(ctx)  
	time.Sleep(time.Second * 3)  
	cancel() // 子goroutineに終了を通知  
	wg.Wait()  
	fmt.Println("over")  
}  

type Context interface {  
    Deadline() (deadline time.Time, ok bool)  
    Done() <-chan struct{}  
    Err() error  
    Value(key interface{}) interface{}  
}  

func WithCancel(parent Context) (ctx Context, cancel CancelFunc)  

func gen(ctx context.Context) <-chan int {  
	dst := make(chan int)  
	n := 1  
	go func() {  
		for {  
			select {  
			case <-ctx.Done():  
				return // このgoroutineを終了してリークを防ぐ  
			case dst <- n:  
				n++  
			}  
		}  
	}()  
	return dst  
}  
func main() {  
	ctx, cancel := context.WithCancel(context.Background())  
	defer cancel() // 必要な整数を取得した後にcancelを呼び出す  

	for n := range gen(ctx) {  
		fmt.Println(n)  
		if n == 5 {  
			break  
		}  
	}  
}  

func WithDeadline(parent Context, deadline time.Time) (Context, CancelFunc)  

func main() {  
	d := time.Now().Add(50 * time.Millisecond)  
	ctx, cancel := context.WithDeadline(context.Background(), d)  

	// ctxは期限切れになりますが、いかなる場合でもcancel関数を呼び出すことは良い習慣です。  
	// そうしないと、コンテキストとその親が必要以上に長く生存する可能性があります。  
	defer cancel()  

	select {  
	case <-time.After(1 * time.Second):  
		fmt.Println("overslept")  
	case <-ctx.Done():  
		fmt.Println(ctx.Err())  
	}  
}  

func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc)  

package main  

import (  
	"context"  
	"fmt"  
	"sync"  

	"time"  
)  

// context.WithTimeout  

var wg sync.WaitGroup  

func worker(ctx context.Context) {  
LOOP:  
	for {  
		fmt.Println("db connecting ...")  
		time.Sleep(time.Millisecond * 10) // 通常のデータベース接続に10ミリ秒かかると仮定  
		select {  
		case <-ctx.Done(): // 50ミリ秒後に自動的に呼び出される  
			break LOOP  
		default:  
		}  
	}  
	fmt.Println("worker done!")  
	wg.Done()  
}  

func main() {  
	// 50ミリ秒のタイムアウトを設定  
	ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*50)  
	wg.Add(1)  
	go worker(ctx)  
	time.Sleep(time.Second * 5)  
	cancel() // 子goroutineに終了を通知  
	wg.Wait()  
	fmt.Println("over")  
}  

func WithValue(parent Context, key, val interface{}) Context  

package main  

import (  
	"context"  
	"fmt"  
	"sync"  

	"time"  
)  

// context.WithValue  

type TraceCode string  

var wg sync.WaitGroup  

func worker(ctx context.Context) {  
	key := TraceCode("TRACE_CODE")  
	traceCode, ok := ctx.Value(key).(string) // 子goroutineでtrace codeを取得  
	if !ok {  
		fmt.Println("無効なtrace code")  
	}  
LOOP:  
	for {  
		fmt.Printf("worker, trace code:%s\n", traceCode)  
		time.Sleep(time.Millisecond * 10) // 通常のデータベース接続に10ミリ秒かかると仮定  
		select {  
		case <-ctx.Done(): // 50ミリ秒後に自動的に呼び出される  
			break LOOP  
		default:  
		}  
	}  
	fmt.Println("worker done!")  
	wg.Done()  
}  

func main() {  
	// 50ミリ秒のタイムアウトを設定  
	ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*50)  
	// システムのエントリポイントでtrace codeを設定し、後続のgoroutineに渡してログデータを集約  
	ctx = context.WithValue(ctx, TraceCode("TRACE_CODE"), "12512312234")  
	wg.Add(1)  
	go worker(ctx)  
	time.Sleep(time.Second * 5)  
	cancel() // 子goroutineに終了を通知  
	wg.Wait()  
	fmt.Println("over")  
}  

// context_timeout/server/main.go  
package main  

import (  
	"fmt"  
	"math/rand"  
	"net/http"  

	"time"  
)  

// サーバー側、ランダムに遅延応答  

func indexHandler(w http.ResponseWriter, r *http.Request) {  
	number := rand.Intn(2)  
	if number == 0 {  
		time.Sleep(time.Second * 10) // 10秒の遅延応答  
		fmt.Fprintf(w, "遅延応答")  
		return  
	}  
	fmt.Fprint(w, "迅速な応答")  
}  

func main() {  
	http.HandleFunc("/", indexHandler)  
	err := http.ListenAndServe(":8000", nil)  
	if err != nil {  
		panic(err)  
	}  
}  

// context_timeout/client/main.go  
package main  

import (  
	"context"  
	"fmt"  
	"io/ioutil"  
	"net/http"  
	"sync"  
	"time"  
)  

// クライアント  

type respData struct {  
	resp *http.Response  
	err  error  
}  

func doCall(ctx context.Context) {  
	transport := http.Transport{  
	   // リクエストが頻繁な場合はグローバルなclientオブジェクトを定義し、長接続を有効にする  
	   // リクエストが頻繁でない場合は短接続を使用  
	   DisableKeepAlives: true,  
	}  
	client := http.Client{  
		Transport: &transport,  
	}  

	respChan := make(chan *respData, 1)  
	req, err := http.NewRequest("GET", "http://127.0.0.1:8000/", nil)  
	if err != nil {  
		fmt.Printf("新しいリクエストの作成に失敗しました, err:%v\n", err)  
		return  
	}  
	req = req.WithContext(ctx) // タイムアウト付きのctxを使用して新しいclientリクエストを作成  
	var wg sync.WaitGroup  
	wg.Add(1)  
	defer wg.Wait()  
	go func() {  
		resp, err := client.Do(req)  
		fmt.Printf("client.do resp:%v, err:%v\n", resp, err)  
		rd := &respData{  
			resp: resp,  
			err:  err,  
		}  
		respChan <- rd  
		wg.Done()  
	}()  

	select {  
	case <-ctx.Done():  
		//transport.CancelRequest(req)  
		fmt.Println("API呼び出しタイムアウト")  
	case result := <-respChan:  
		fmt.Println("サーバーAPI呼び出し成功")  
		if result.err != nil {  
			fmt.Printf("サーバーAPI呼び出しに失敗しました, err:%v\n", result.err)  
			return  
		}  
		defer result.resp.Body.Close()  
		data, _ := ioutil.ReadAll(result.resp.Body)  
		fmt.Printf("resp:%v\n", string(data))  
	}  
}  

func main() {  
	// 100ミリ秒のタイムアウトを定義  
	ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*100)  
	defer cancel() // cancelを呼び出して子goroutineのリソースを解放  
	doCall(ctx)  
}