NoteConcurrent in for Go loop

I have written code to get the percent of usage on CPU core. If the CPU usage in one core is lower than 50% I will run stress test code to increase usage percent higher than 50%. I must appy this policy for all CPU cores.

Here is my full code:

package main
import (
"fmt"
"io/ioutil"
"net/http"
"os"
"strconv"
"strings"
"time"
"github.com/dhoomakethu/stress/utils"
strip "github.com/grokify/html-strip-tags-go"
)
func main() {
url := "http://localhost:8080/getCPU"
resp := Get(url)
//remove htlm tag
stripped := strip.StripTags(resp)
s := strings.Split(stripped, "%")
var j []int
for i := 0; i < len(s)-1; i++ {
number, _ := strconv.Atoi(s[i])
if number < 50 {
j = append(j, i)
}
}
fmt.Println(j)
sampleInterval := 100 * time.Millisecond
cpuload := 1.0
duration := 300.0
for a := 0; a < len(j)/2; a++ {
cpucore := j[a]
runCpuLoader(sampleInterval, cpuload, duration, cpucore)
}
}
//GET
func Get(url string) string {
response, err := http.Get(url)
if err != nil {
fmt.Printf("%s", err)
os.Exit(1)
} else {
defer response.Body.Close()
contents, err := ioutil.ReadAll(response.Body)
if err != nil {
fmt.Printf("%s", err)
os.Exit(1)
}
return string(contents)
}
return ""
}
// stress cpu
func runCpuLoader(sampleInterval time.Duration, cpuload float64, duration float64, cpu int)   {
controller := utils.NewCpuLoadController(sampleInterval, cpuload)
monitor := utils.NewCpuLoadMonitor(float64(cpu), sampleInterval)
actuator := utils.NewCpuLoadGenerator(controller, monitor, time.Duration(duration))
utils.StartCpuLoadController(controller)
utils.StartCpuMonitor(monitor)
utils.RunCpuLoader(actuator)
utils.StopCpuLoadController(controller)
utils.StopCpuMonitor(monitor)
}

In this part of code

for a := 0; a < len(j)/2; a++ {
cpucore := j[a]
runCpuLoader(sampleInterval, cpuload, duration, cpucore)
}
}

I want the code concurrent run stress test to increase percent of CPU usage. But the function runCpuLoader(sampleInterval, cpuload, duration, cpucore) have duration in 5 minutes so it cannot run as concurrent.

Note:

Output of GET function like image bellow:

You should complete the Tour of Go and focus specifically on go routines as well as check out wait groups. I'll cover the applicable concepts briefly here.

The go keyword

In go, running functions concurrently is extremely easy. Given the following code, I need only add the go prefix in front of blockingCode to make it run concurrently with the rest of the program.

func blockingCode() {
time.Sleep(time.Second)
fmt.Println("finishing blocking")
}
func main() {
fmt.Println("starting main")
go blockingCode()
fmt.Println("finishing main")
}

You'll notice a couple things about this:

• If I remove the go prefix, the function will block and you will see all three print statements, the last two being printed a second later than the first one (go playground).
• If I add the go prefix back in, the function will not block, but you will not see the fmt.Println("finishing blocking") print statement. This is because the main function (the main go-routine) terminates before blockingCode finishes. This is where wait groups come into play.

WaitGroup

> To wait for multiple goroutines to finish, we can use a wait group. https://gobyexample.com/waitgroups.

Think of a wait group as an atomic counter, where calls to wg.Wait block until the counter is 0. As you spawn go-routines, you increment the counter (wg.Add), as you finish go-routines, you de-increment the counter (wg.Done). Here is the code with support for wait groups. go playground

func blockingCode(wg *sync.WaitGroup) {
defer wg.Done()
time.Sleep(time.Second)
fmt.Println("finishing blocking")
}
func main() {
wg := sync.WaitGroup{}
fmt.Println("starting main")
wg.Add(1)
go blockingCode(&wg)
wg.Wait()
fmt.Println("finishing main")
}

Now this results in the exact same behavior we saw above -- the function will block and you will see all three print statements, the last two being printed a second later than the first -- so why did we make this concurrent in the first place? The difference is, we can run many things concurrently now, rather than many things sequentially. The reason we don't see the benefits of concurrency in this case is because we're only doing one thing concurrently.

Let's adapt our example to run blockingCode several times. What you'll notice is that the script takes virtually the same amount of time to run, even though we're calling our blockingCode that takes a full second to run, three times, if we remove the go keyword and the wait groups, we would see this code take at least three seconds to run go playground.

func blockingCode(wg *sync.WaitGroup) {
defer wg.Done()
time.Sleep(time.Second)
fmt.Println("finishing blocking")
}
func main() {
wg := sync.WaitGroup{}
fmt.Println("starting main")
wg.Add(1)
go blockingCode(&wg)
wg.Add(1)
go blockingCode(&wg)
wg.Add(1)
go blockingCode(&wg)
wg.Wait()
fmt.Println("finishing main")
}

Your example

How you choose to handle concurrent behavior depends a lot on the specifics of your application, however something like this should implement the concurrency concepts I provided here and allow you to run your monitors concurrently with your loaders.

func main() {
// ...
wg := sync.WaitGroup{}
for a := 0; a < len(j)/2; a++ {
cpucore := j[a]
wg.Add(1)
go runCpuLoader(&wg, sampleInterval, cpuload, duration, cpucore)
}
wg.Wait()
}
func runCpuLoader(wg *sync.WaitGroup, sampleInterval time.Duration, cpuload float64, duration float64, cpu int) {
defer wg.Done()
// ...
}