Solution 5: Go Concurrency

package main

import (
	"fmt"
	"os"
	"os/exec"
	"runtime"
	"strconv"
	"strings"
	"sync"
	"time"
)

type Client struct {
	id   int
	text string
}

type Result struct {
	job      Client
	lines    int
	words    int
	characters int
}

var size = runtime.GOMAXPROCS(0)
var clients = make(chan Client, size)
var data = make(chan Result, size)

func worker(wg *sync.WaitGroup) {
	for c := range clients {
		cmd := exec.Command("wc", "-l", "-w", "-c")
		cmd.Stdin = strings.NewReader(c.text)
		out, err := cmd.Output()
		if err != nil {
			fmt.Println(err)
			continue
		}
		output := strings.Fields(string(out))
		lines, _ := strconv.Atoi(output[0])
		lines++
		words, _ := strconv.Atoi(output[1])
		characters, _ := strconv.Atoi(output[2])
		res := Result{c, lines, words, characters}
		data <- res
		time.Sleep(time.Second)
	}
	wg.Done()
}

func create(n int) {
	for i := 0; i < n; i++ {
		c := Client{i, "Hello World!"}
		clients <- c
	}
	close(clients)
}

func main() {
	if len(os.Args) != 3 {
		fmt.Println("Need #jobs and #workers!")
		return
	}

	nJobs, err := strconv.Atoi(os.Args[1])
	if err != nil {
		fmt.Println(err)
		return
	}

	nWorkers, err := strconv.Atoi(os.Args[2])
	if err != nil {
		fmt.Println(err)
		return
	}

	go create(nJobs)

	finished := make(chan interface{})
	go func() {
		for d := range data {
			fmt.Printf("Client ID: %d\tlines: %d\twords: %d\tcharacters: %d\n", d.job.id, d.lines, d.words, d.characters)
		}
		finished <- true
	}()

	var wg sync.WaitGroup
	for i := 0; i < nWorkers; i++ {
		wg.Add(1)
		go worker(&wg)
	}
	wg.Wait()
	close(data)

	fmt.Printf("Finished: %v\n", <-finished)
}