title: Timer example using timer.Reset() not working as described
body: <p>I've been working with examples trying to get my first "go routine" running and while I got it running, it won't work as prescribed by the go documentation with the timer.Reset() function.</p>
  
  <p>In my case I believe that the way I am doing it is just fine because I don't actually care what's in the chan buffer, if anything. All as this is meant to do is trigger <code>case &lt;-tmr.C:</code> if anything happened on <code>case _, ok := &lt;-watcher.Events:</code> and then all goes quiet for at least one second. The reason for this is that <code>case _, ok := &lt;-watcher.Events:</code> can get from one to dozens of events microseconds apart and I only care once they are all done and things have settled down again.</p>
  
  <p>However I'm concerned that doing it the way that the documentation says you "must do" doesn't work. If I knew go better I would say the documentation is flawed because it assumes there is something in the buffer when there may not be but I don't know go well enough to have confidence in making that determination so I'm hoping some experts out there can enlighten me.</p>
  
  <p>Below is the code. I haven't put this up on playground because I would have to do some cleaning up (remove calls to other parts of the program) and I'm not sure how I would make it react to filesystem changes for showing it working.</p>
  
  <p>I've clearly marked in the code which alternative works and which doesn't.</p>
  
  <pre><code>func (pm *PluginManager) LoadAndWatchPlugins() error {
  
    // DOING OTHER STUFF HERE
  
      fmt.Println(`m1`)
  
      done := make(chan interface{})
      terminated := make(chan interface{})
  
      go pm.watchDir(done, terminated, nil)
      fmt.Println(`m2.pre-10`)
  
      time.Sleep(10 * time.Second)
  
      fmt.Println(`m3-post-10`)
  
      go pm.cancelWatchDir(done)
      fmt.Println(`m4`)
  
      &lt;-terminated
      fmt.Println(`m5`)
  
      os.Exit(0) // Temporary for testing
  
      return Err
  }
  
  func (pm *PluginManager) cancelWatchDir(done chan interface{}) {
      fmt.Println(`t1`)
  
      time.Sleep(5 * time.Second)
      fmt.Println()
      fmt.Println(`t2`)
  
      close(done)
  }
  
  func (pm *PluginManager) watchDir(done &lt;-chan interface{}, terminated chan interface{}, strings &lt;-chan string) {
  
    watcher, err := fsnotify.NewWatcher()
      if err != nil {
          Logger("watchDir::"+err.Error(), `plugins`, Error)
      }
  
      //err = watcher.Add(pm.pluginDir)
      err = watcher.Add(`/srv/plugins/`)
      if err != nil {
          Logger("watchDir::"+err.Error(), `plugins`, Error)
      }
  
      var tmr = time.NewTimer(time.Second)
      tmr.Stop()
  
      defer close(terminated)
      defer watcher.Close()
      defer tmr.Stop()
      for {
          select {
          case &lt;-tmr.C:
              fmt.Println(`UPDATE FIRED`)
              tmr.Stop()
  
          case _, ok := &lt;-watcher.Events:
              if !ok {
                  return
              }
  
              fmt.Println(`Ticker: STOP`)
              /*
               *  START OF ALTERNATIVES
               *
               *  THIS IS BY EXAMPLE AND STATED THAT IT "MUST BE" AT:
               *      https://golang.org/pkg/time/#Timer.Reset
               *
               *  BUT DOESN'T WORK
               */
              if !tmr.Stop() {
                  fmt.Println(`Ticker: CHAN DRAIN`)
                  &lt;-tmr.C // STOPS HERE AND GOES NO FURTHER
              }
              /*
               *  BUT IF I JUST DO THIS IT WORKS
               */
              tmr.Stop()
              /*
               *  END OF ALTERNATIVES
               */
  
              fmt.Println(`Ticker: RESET`)
              tmr.Reset(time.Second)
  
          case &lt;-done:
              fmt.Println(`DONE TRIGGERED`)
              return
          }
      }
  }
  </code></pre>