example_test.go

Documentation: context

		 1  // Copyright 2016 The Go Authors. All rights reserved.
		 2  // Use of this source code is governed by a BSD-style
		 3  // license that can be found in the LICENSE file.
		 4  
		 5  package context_test
		 6  
		 7  import (
		 8  	"context"
		 9  	"fmt"
		10  	"time"
		11  )
		12  
		13  const shortDuration = 1 * time.Millisecond // a reasonable duration to block in an example
		14  
		15  // This example demonstrates the use of a cancelable context to prevent a
		16  // goroutine leak. By the end of the example function, the goroutine started
		17  // by gen will return without leaking.
		18  func ExampleWithCancel() {
		19  	// gen generates integers in a separate goroutine and
		20  	// sends them to the returned channel.
		21  	// The callers of gen need to cancel the context once
		22  	// they are done consuming generated integers not to leak
		23  	// the internal goroutine started by gen.
		24  	gen := func(ctx context.Context) <-chan int {
		25  		dst := make(chan int)
		26  		n := 1
		27  		go func() {
		28  			for {
		29  				select {
		30  				case <-ctx.Done():
		31  					return // returning not to leak the goroutine
		32  				case dst <- n:
		33  					n++
		34  				}
		35  			}
		36  		}()
		37  		return dst
		38  	}
		39  
		40  	ctx, cancel := context.WithCancel(context.Background())
		41  	defer cancel() // cancel when we are finished consuming integers
		42  
		43  	for n := range gen(ctx) {
		44  		fmt.Println(n)
		45  		if n == 5 {
		46  			break
		47  		}
		48  	}
		49  	// Output:
		50  	// 1
		51  	// 2
		52  	// 3
		53  	// 4
		54  	// 5
		55  }
		56  
		57  // This example passes a context with an arbitrary deadline to tell a blocking
		58  // function that it should abandon its work as soon as it gets to it.
		59  func ExampleWithDeadline() {
		60  	d := time.Now().Add(shortDuration)
		61  	ctx, cancel := context.WithDeadline(context.Background(), d)
		62  
		63  	// Even though ctx will be expired, it is good practice to call its
		64  	// cancellation function in any case. Failure to do so may keep the
		65  	// context and its parent alive longer than necessary.
		66  	defer cancel()
		67  
		68  	select {
		69  	case <-time.After(1 * time.Second):
		70  		fmt.Println("overslept")
		71  	case <-ctx.Done():
		72  		fmt.Println(ctx.Err())
		73  	}
		74  
		75  	// Output:
		76  	// context deadline exceeded
		77  }
		78  
		79  // This example passes a context with a timeout to tell a blocking function that
		80  // it should abandon its work after the timeout elapses.
		81  func ExampleWithTimeout() {
		82  	// Pass a context with a timeout to tell a blocking function that it
		83  	// should abandon its work after the timeout elapses.
		84  	ctx, cancel := context.WithTimeout(context.Background(), shortDuration)
		85  	defer cancel()
		86  
		87  	select {
		88  	case <-time.After(1 * time.Second):
		89  		fmt.Println("overslept")
		90  	case <-ctx.Done():
		91  		fmt.Println(ctx.Err()) // prints "context deadline exceeded"
		92  	}
		93  
		94  	// Output:
		95  	// context deadline exceeded
		96  }
		97  
		98  // This example demonstrates how a value can be passed to the context
		99  // and also how to retrieve it if it exists.
	 100  func ExampleWithValue() {
	 101  	type favContextKey string
	 102  
	 103  	f := func(ctx context.Context, k favContextKey) {
	 104  		if v := ctx.Value(k); v != nil {
	 105  			fmt.Println("found value:", v)
	 106  			return
	 107  		}
	 108  		fmt.Println("key not found:", k)
	 109  	}
	 110  
	 111  	k := favContextKey("language")
	 112  	ctx := context.WithValue(context.Background(), k, "Go")
	 113  
	 114  	f(ctx, k)
	 115  	f(ctx, favContextKey("color"))
	 116  
	 117  	// Output:
	 118  	// found value: Go
	 119  	// key not found: color
	 120  }
	 121
View as plain text