type Ticker struct {
    C          <-chan Time // The channel on which the ticks are delivered.
    initTicker bool
}

func main() {
    ticker := time.NewTicker(1 * time.Second)

    defer ticker.Stop()

    for range ticker.C {
       log.Println("tick")
    }
}

func TickerLaunch() {
    //5分鐘執(zhí)行一次.
    ticker := time.NewTicker(5 * time.Minute)

    defer ticker.Stop()
    maxPassenger := 30
    passengers := make([]string, 0, maxPassenger)
    for {
       passenger := GetNewPassenger()
       if passenger != "" {
          passengers = append(passengers, passenger)
       } else {
          time.Sleep(1 * time.Second)
       }
       select {
       case <-ticker.C:
          Launch(passengers)
          passengers = []string{}
       default:
          if len(passengers) >= maxPassenger {
             Launch(passengers)
             passengers = []string{}
          }
       }
    }
}

func Launch(passengers []string) {
    for i := range passengers {
       fmt.Println(passengers[i], "發(fā)車了")
    }
}

func GetNewPassenger() string {
    return "乘客"
}

func NewTicker(d Duration) *Ticker {
    if d <= 0 {
       panic("non-positive interval for NewTicker")
    }
    // Give the channel a 1-element time buffer.
    // If the client falls behind while reading, we drop ticks
    // on the floor until the client catches up.
    c := make(chan Time, 1)
    t := (*Ticker)(unsafe.Pointer(newTimer(when(d), int64(d), sendTime, c, syncTimer(c))))
    t.C = c
    return t
}

// Stop turns off a ticker. After Stop, no more ticks will be sent.
// Stop does not close the channel, to prevent a concurrent goroutine
// reading from the channel from seeing an erroneous "tick".
func (t *Ticker) Stop() {
    if !t.initTicker {
       // This is misuse, and the same for time.Timer would panic,
       // but this didn't always panic, and we keep it not panicking
       // to avoid breaking old programs. See issue 21874.
       return
    }
    stopTimer((*Timer)(unsafe.Pointer(t)))
}

func Tick(d Duration) <-chan Time {
    if d <= 0 {
       return nil
    }
    return NewTicker(d).C
}

func WrongTicker() {
    for  {
       select {
       case <-time.Tick(time.Second):
          log.Printf("resource leak!")
       }
    }
}