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)
}