interrupt pattern for google go goroutine (speed issue)

I run a goroutine to increment a counter, which can be interrupted by command line input "t\n"

In the select statement, if I choose to use default:, the counter variable j flies forword. That seems normal to me.

However, if I choose to use case <-time.After(100*time.Microsecond):, the counter j only adds up to 60 or so in one second, instead of 10,000.

In fact no matter what value I put in time.After(), I only get about 60Hz rate running through the select statement.

Why?

package main
import (
	"bufio"
	"fmt"
	"os"
	"strings"
	"time"
)
func main() {
	message := make(chan string)
	go check_input(message)
	work_loop(message)
}
func work_loop(message chan string) {
	//var j [][]int
	var j int
	t0:=time.Now()
Loop:
	for {
		select {
		case msg := <-message:
			if msg == "terminate" {
				//fmt.Println("end task")
				t1:=time.Now()
				fmt.Println(j)
				fmt.Println("total duration:", t1.Sub(t0))
				break Loop
			}
		case <-time.After(100 * time.Microsecond):
		//default:
			//do work here			
			j += 1
			fmt.Println(j)
			break
		}
	}
	//fmt.Println("exit work loop")
}
func check_input(msg chan string) {
	reader := bufio.NewReader(os.Stdin)
	for {
		line, err := reader.ReadString('\n')
		if err != nil {
			// You may check here if err == io.EOF
			break
		}
		if strings.TrimSpace(line) == "t" {
			msg <- "terminate"
		}
	}
}

It has to do with the precision of time.Timer. Looking at the documentation of time.After:

> [...] It is equivalent to NewTimer(d).C.

and the documentation of time.NewTimer:

> NewTimer creates a new Timer that will send the current time on its channel after at least duration d.

(emphasis mine)

The reason for this is that NewTimer delegates to a runtime (OS-dependent) timer,making the behavior of this timer dependent on the underlying OS (and the implementation of the Go integration).

In general, it is my experience that sub-millisecond granularity does not have good cross-platform support in any language, especially on Windows XP.