Go countdown timer in loop

I currently have this code that is trying to count the elapsed time to trigger a certain condition. (pseudo):

timeDelay = 900000 // time.Microsecond
for {
   // if a certain something happens, start a counting (time)
   if (certainSomething) {
      startTime = time.Now();

      if !prevTime.IsZero() {
        // add the time elapsed time to timeTick
        diffTime = time.Since(prevTime)
        timeTick = timeTick + diffTime
      }

      prevTime = startTime
   }

   if (timeTick < timeDelay) { // lessThan()
      // still has not reached target count (time elapsed)
      fmt.Println("Not Yet")
      // we dont want to get to the end of the loop yet
      continue
   }

   if (timeTick > timeDelay) { // greaterThan()
      // has finally reached the target count (time elapsed)
      fmt.Println("Yes! Finally")
      // yes the delay has been reached lets reset the time
      // and if `thisHappened` is triggered again, lets start counting again
      timeTick = time.Duration(0 * time.Microsecond)
   }

   // function shouldn't be called if the elapsed amount
   //      of time required has not yet been reached
   iShouldOnlyBeCalledWhenDelayHasBeenReached();
}

I'm also using these as helper functions (actual code)

func lessThan(diff time.Duration, upper int) bool {
	return diff < time.Duration(upper)*time.Microsecond && diff != 0
}

func greaterThan(diff time.Duration, upper int) bool {
	return diff > time.Duration(upper)*time.Microsecond
}

But, I'm just not comfortable of how I'm doing it. I shouldn't be counting up, right? I should be counting down... I'm just confused and need help on what approach I should use.

What I want to happen:

1. A countdown from timeDelay to 0 starts when certainSomething happens.
2. Do not call iShouldOnlyBeCalledWhenDelayHasBeenReached until the countdown hits 0.
3. This should all happen inside a loop, a server loop receiving packets to be exact.

My question:

1. What should I do to achieve that countdown style?

Thank you, any suggestion or example code would help a lot.

> Note: There are other functions in the loop. Doing other things. This is the main loop. I can't make it Sleep.

You can setup a channel to let you know when you've exceeded the time.

Here's an example on play

It has an added benefit that in the select statement, you can have other channels for other purposes. For example,if you are doing other work in this loop, you could also spawn that work in a goroutine and have it send the result back on another channel.
Then you exit after timeDelay or when other work completes, or whatever.

package main

import (
	"fmt"
	"time"
)

func main() {
	certainSomething := true // will cause time loop to repeat

	timeDelay := 900 * time.Millisecond // == 900000 * time.Microsecond

	var endTime <-chan time.Time // signal for when timer us up

	for {
		// if a certain something happens, start a timer
		if certainSomething && endTime == nil {
			endTime = time.After(timeDelay)
		}
		select {
		case <-endTime:
			fmt.Println("Yes Finally!")
			endTime = nil
		default:
			fmt.Println("not yet")
			time.Sleep(50 * time.Millisecond) // simulate work
			continue
		}

		// function shouldn't be called if the elapsed amount
		//      of time required has not yet been reached
		iShouldOnlyBeCalledWhenDelayHasBeenReached() // this could also just be moved to the <- endtime block above
	}
}

func iShouldOnlyBeCalledWhenDelayHasBeenReached() {
	fmt.Println("I've been called")
}

Since this is a game as you say, it sounds to me that you:

• want to do X amount of work
• if the time of work exceeds delay amount, stop work and loop again

If this is the case, then you have a few options and patterns.

time.After come to mind.

I like the cleanliness of time.After in a select statement. No channels or goroutines needed to handle it.

This pattern also has the added benefit of using goroutines for your main game logic.

On play: http://play.golang.org/p/FIiUJ0CHZz

Change the time.After() to see it in action.

func main() {
    
	for {
	
		// creating a new channel on each loop will allow the
		// GC to collect any game stuff that completes after the timeout.
		done := make(chan int)
		
		// main game func, doing your other stuff.
		// since this is in a goroutine, it won't block
		// and we can check the state in the select.
		go func(){
		
			// complicated logic here!
			//
			
			// you must issue an "I am done!"
			done <- 1
		}()

		// this will block the for loop until a timeout occurs
		select {
			case <- done:
				continue
			case <- time.After(1000 * time.Nanosecond):
				iShouldOnlyBeCalledWhenDelayHasBeenReached()
		}
	}
}

If you can't make the routine sleep, you should use the time.Time.Add and time.Time.After (or time.Time.Before) functions.

Something along theses lines

package main         
                     
import "time"        
                     
func main() {        
                     
    var d = 1000 * time.Microsecond
    var t = time.Now().Add(d)
                     
    for {            
        if time.Now().Before(t) {
            continue 
        }            
                     
        do_something()
    }                
}

Or deport the method you have to run after a certain time in a routine that you can make sleep:

package main         
                     
import "time"        
                     
func main() {

    var d = 1000 * time.Microsecond

    go func() {
        time.Sleep(d)
        do_something()
    }()
}

I think this will solve your problem.

package main

import (
    "fmt"
    "time"
)

func main() {
    time.Sleep(2 * time.Second)
    fmt.Println("Time is up!")
}

<kbd>Playground</kbd>