func (mc *mysqlConn) startWatcher() {
	// executor goritune と `context.Context` のやり取りをするための channel
	watcher := make(chan context.Context, 1)
	mc.watcher = watcher

	// executor goritune で処理が完了したことを知るための channel
	finished := make(chan struct{})
	mc.finished = finished

	// コネクションがCloseされたことを知らせるための channel
	mc.closech = make(chan struct{})

	// ここから watcher goroutine 本体
	go func() {
		for {
			// executor goritune から `context.Context` を待ち受ける
			var ctx context.Context
			select {
			case ctx = <-watcher:
			case <-mc.closech:
				// コネクションが Close されたので watcher gorutine を終了する
				return
			}

			// `context.Context` を監視する
			select {
			case <-ctx.Done():
				// executor goritune を強制終了する
				mc.cancel(ctx.Err())
			case <-finished:
				// 正常に処理が終了したので何もしない
			case <-mc.closech:
				// コネクションが Close されたので watcher gorutine を終了する
				return
			}
		}
	}()
}

// 何かやる
func (mc *mysqlConn) DoSomething(ctx context.Context) error {
	// watcher gorutineにctxを渡して監視してもらう
	if err := mc.watchCancel(ctx); err != nil {
		return err
	}

	// doSomthing()が実際に行いたい処理
	if err := mc.doSomthing(); err != nil {
		// キャンセルされたのか、ネットワークエラーで切断されたのか、を確認する
		if cerr := mc.canceled(); cerr != nil {
			return cerr
		}
		return err
	}

	// watcher gorutineに処理が終了したことを通知する
	mc.finish()

	return nil
}

func (mc *mysqlConn) watchCancel(ctx context.Context) error {
	// 実際の処理が始まるまえに、 `ctx` が終了していないか確認
	select {
	default:
	case <-ctx.Done():
		return ctx.Err()
	}

	// watcher goroutineに渡す
	mc.watcher <- ctx

	return nil
}

func (mc *mysqlConn) finish() {
	select {
	case mc.finished <- struct{}{}:
	case <-mc.closech:
	}
}

// キャンセルを実行する
func (mc *mysqlConn) cancel(err error) {
	// **コネクションを実際にCloseする前** にエラー内容を記録する
	mc.mu.Lock()
	mc.canceledErr = err
	mc.mu.Unlock()

	// 強制切断
	mc.cleanup()
}

// キャンセルされたか確認用
func (mc *mysqlConn) canceled() error {
	mc.mu.Lock()
	defer mc.mu.Unlock()
	return mc.canceledErr
}

func (mc *mysqlConn) cleanup() {
	// closeが2回以上実行されないようガード
	if atomic.SwapInt32(&mc.closed, 1) != 0 {
		return
	}

	// (executor|watcher) goroutineに終了を通知
	close(mc.closech)

	// コネクションを切断
	mc.netConn.Close()
}

for ctx := range watcher {
	// context.Context監視処理
}

ctx, cancel := context.WithCancel(context.Background())
rows, _ := dbt.db.QueryContext(ctx, "SELECT v FROM test")
rows.Next()
if err := rows.Scan(&v); err != nil {
	panic(err)
}

cancel()
time.Sleep(100 * time.Millisecond)

rows.Next()
// rows.Err() は context.Canceled になっているべき
if err := rows.Err(); err != context.Canceled {
	panic(err)
}

package main

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

func main() {
	log.SetFlags(log.LstdFlags | log.Lshortfile)

	// 1秒わざとレスポンスを返さないサーバー
	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Context-Type", "text/plain")
		w.WriteHeader(200)
		fmt.Fprint(w, "Hello, ")
		w.(http.Flusher).Flush()
		time.Sleep(time.Second)
		fmt.Fprint(w, "client\n")
	}))
	defer ts.Close()

	req, err := http.NewRequest("GET", ts.URL, nil)
	if err != nil {
		log.Fatal(err)
	}

	// 0.5秒後にキャンセル
	ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
	go func() {
		time.Sleep(500 * time.Millisecond)
		cancel()
	}()
	defer cancel()

	req = req.WithContext(ctx)
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		log.Fatal(err)
	}

	// ioutil.ReadAll は "context canceled" か "context deadline exceeded" で失敗する
	greeting, err := ioutil.ReadAll(res.Body)
	res.Body.Close()
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("%s", greeting)
}