package main

// A system in Go to limit the number of running threads
// This behaves a lot like the Java FixedThreadPool Executor
// the idea is to create a single "channel" where a channel is a way
// of passing messages into threads.
// Then start the number of threads you want to allow to run.
// Put messages onto the thread for the total number of tasks you
// want to do in the threads. So then what happens is the thread runs in
// a loop where it tries to read from the channel. If success, it does work.
// When work complete, it reads from channel again. If fail to read (which
// happens when there are no more messages to read) then thread dies.
// You could have the threads do different things by putting into
// the channel an instruction about what to do.
//
// Note that channels are usually used to implement message passing
// between threads (which is what this is doing, just unidirectionally and
// quite boring.)

import (
	"fmt"
	"sync"
)

const xthreads = 3 // Total number of threads to use, excluding the main() thread
const times = 100000000  // the amount of counting to do
const reps = 8 // the number of times to count.

var counter int64

// a stupid function
func doSomething(times int) {
    for th:=0; th<times; th++ {
		counter++
	}
    return
}

func main() {
    var ch = make(chan int) 
    var wg sync.WaitGroup

    // This starts xthreads number of goroutines that wait for something to do
    wg.Add(xthreads)
    // idea start "xthreads" threads
    // Each thread reads from "channel"
    for i:=0; i<xthreads; i++ {
        go func(threadCounter int) {
            for {
                // so long as the channel is open, or has more messages, 
                // the channel read will either wait for a message to read
                val, ok := <-ch
                if !ok { // if there is nothing to do and the channel has been closed then end the goroutine
                    wg.Done()
                    return
                }
                fmt.Printf("Started %v message: %v\n", threadCounter, val)
                doSomething(val) // do the thing
                fmt.Printf("Thread %v done\n", threadCounter)
            }
        }(i)
    }

    // this loop controls the number of tasks done.
    // (And potentially what the task is)
    for i:=0; i<reps; i++ {
        ch <- times
    }

    close(ch) // This tells the goroutines there's nothing else to do
    wg.Wait() // Wait for the threads to finish
	fmt.Printf("Reps: %v   Count:%v\n", reps, times)
	fmt.Printf("Total count %v   shortfall:%v\n", counter, (int64((times*reps))-counter))
}