Parallelism From Slices

I want to make it run parallel based on number of thread. But the result was not as i expected. I dont know how to make it efficient and fast.

I ended up with this code.

package main
import (
"fmt"
"io/ioutil"
"net/http"
"os"
"runtime"
"strconv"
"strings"
"sync"
"time"
)
func main() {
start := time.Now()
target := os.Args[1]
thread, _ := strconv.Atoi(os.Args[3])
file, err := ioutil.ReadFile(os.Args[2])
if err != nil {
fmt.Println("Error: Please double check if the file " + os.Args[2] + " is exist!")
os.Exit(0)
}
wordlist := strings.Split(string(file), "\n")
var wg sync.WaitGroup
runtime.GOMAXPROCS(runtime.NumCPU())
jobs := make(chan string)
for i := 0; i < thread; i++ {
wg.Add(1)
defer wg.Done()
for _, word := range wordlist {
go func(word string) {
jobs <- word
}(word)
}
}
go func() {
for job := range jobs {
code := visit(target + job)
fmt.Println(target + job + " - " + strconv.Itoa(code))
}
}()
wg.Wait()
elapsed := time.Since(start)
fmt.Printf("Timer: %s\n", elapsed)
}
func visit(url string) int {
data, err := http.Get(url)
if err != nil {
panic(err)
}
return data.StatusCode
}

Any help would be appreciated. Thank you.

Update
This is my current results :

$ go run test.go http://localhost/ word.txt 2
http://localhost/1 - 404
http://localhost/1 - 404
http://localhost/7 - 404
http://localhost/8 - 404
http://localhost/9 - 404
http://localhost/0 - 404
http://localhost/ - 200
http://localhost/3 - 404
http://localhost/2 - 404
http://localhost/4 - 404
http://localhost/6 - 404
http://localhost/2 - 404
http://localhost/3 - 404
http://localhost/4 - 404
http://localhost/5 - 404
http://localhost/9 - 404
http://localhost/7 - 404
http://localhost/8 - 404
http://localhost/0 - 404
http://localhost/5 - 404
http://localhost/ - 200
http://localhost/6 - 404

You are not using the waitgroup correctly. The defer's in main's for loop are never called since main never returns and as a result, wg.Wait() call never unblocks.

Put defer calls in the goroutine sending the message:

// ...
for i := 0; i < thread; i++ {
wg.Add(1)
for _, word := range wordlist {
go func(word string) {
defer wg.Done()
jobs <- word
}(word)
}
}
// ...

Also close the jobs channel:

// ...
wg.Wait()
close(jobs)
// ...

You should create new goroutine per new job, not per new job added

Here you're creating a log of goroutines to push only 1 word to channel. This is an overkill for such a simple operation.

    for _, word := range wordlist {
go func(word string) {
jobs <- word
}(word)
}

But job with fetching url is more heavier, but start only 1 goroutine for this.

go func() {
for job := range jobs {
code := visit(target + job)
fmt.Println(target + job + " - " + strconv.Itoa(code))
}
}()

As @abhink has mentioned you're not using WaitGroup correctly. Do wg.Add(1) before creating each goroutine and do wg.Done() at the end of each goroutine. And of course wg.Wait() to wait all running goroutines to finish. Example:

var wg sync.WaitGroup
wg.Add(1)   
go func(param){
defer wg.Done()
//...
}(url)
//...
wg.Wait()