async

// we create an input and output channel for work needing to be done
inCh := make(chan string, 128)
outCh := make(chan int, 128)

// we want a max of 10 in-flight processes
s := NewCountingSemaphore(10)

// we create more workers than tokens available
for i := 0; i < 100; i++ {
	go func() {
		for {
			// acquire a token, waiting until one is available
			s.Acquire(1)

			// consume from the input channel
			v, ok := <-inCh
			if !ok {
				// channel was closed
				return
			}

			// do some work and produce an output value
			outCh <- len(v)

			// you need to be careful about releasing, if possible perform it with defer
			s.Release(1)
		}
	}()
}

// generate some work and put it into the work queue
// ...
// ...

Output:

// create a string future
f := NewFuture[string]()

// create a consumer channel
ch := f.Get()
go func() {
	println(fmt.Sprintf("Value: %s", <-ch))
}()

// set the value
f.Set("hello")

Output:

// create some futures
foo := NewFuture[string]()
bar := NewFuture[string]()

// compute in the background
go func() {
	foo.Set("foo")
}()

go func() {
	foo.Set("bar")
}()

// wait for their results
println(<-foo.Get())
println(<-bar.Get())

Output:

// create some futures
foo := NewFuture[string]()
bar := NewFuture[string]()

// compute their values in the background
go func() {
	foo.Set("foo")
}()

go func() {
	bar.Set("bar")
}()

// create some consumer channels
fooCh := foo.Get()
barCh := bar.Get()

// wait with timeout

ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
defer cancel()

var result []string
finished := false

for {
	select {
	case <-ctx.Done():
		fmt.Println("timeout")
		finished = true
	case v, ok := <-fooCh:
		if ok {
			result = append(result, v)
		}
		finished = len(result) == 2
	case v, ok := <-barCh:
		if ok {
			result = append(result, v)
		}
		finished = len(result) == 2
	}

	if finished {
		// break out of the loop
		break
	}
}

// print all the results
fmt.Println(result)

Output: