Why is this golang script giving me a deadlock ? + a few questions

I got this code from someone on github and I am trying to play around with it to understand concurrency.

package main

import (
	"bufio"
	"fmt"
	"os"
	"sync"
	"time"
)

var wg sync.WaitGroup

func sad(url string) string {
	fmt.Printf("gonna sleep a bit\n")
	time.Sleep(2 * time.Second)
	return url + " added stuff"
}

func main() {
	sc := bufio.NewScanner(os.Stdin)
	urls := make(chan string)
	results := make(chan string)

	for i := 0; i < 20; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			for url := range urls {
				n := sad(url)
				results <- n
			}
		}()
	}

	for sc.Scan() {
		url := sc.Text()
		urls <- url
	}

	for result := range results {
		fmt.Printf("%s arrived\n", result)
	}

	wg.Wait()
	close(urls)
	close(results)
}

I have a few questions:

1. Why does this code give me a deadlock?
2. How does that for loop exist before the operation of taking in input from user does the go routines wait until anything is passes in the urls channel then start doing work? I don't get this because it's not sequential, like why is taking in input from user then putting every input in the urls channel then running the go routines is considered wrong?
3. Inside the for loop I have another loop which is iterating over the urls channel, does each go routine deal with exactly one line of input? or does one go routine handle multiple lines at once? how does any of this work?
4. Am i gathering the output correctly here?

Mostly you're doing things correctly, but have things a little out of order. The for sc.Scan() loop will continue until Scanner is done, and the for result := range results loop will never run, thus no go routine ('main' in this case) will be able to receive from results. When running your example, I started the for result := range results loop before for sc.Scan() and also in its own go routine--otherwise for sc.Scan() will never be reached.

go func() {
for result := range results {
fmt.Printf("%s arrived\n", result)
}
}()
for sc.Scan() {
url := sc.Text()
urls <- url
}

Also, because you run wg.Wait() before close(urls), the main goroutine is left blocked waiting for the 20 sad() go routines to finish. But they can't finish until close(urls) is called. So just close that channel before waiting for the waitgroup.

close(urls)
wg.Wait()
close(results)

The for-loop creates 20 goroutines, all waiting input from the urls channel. When someone writes into this channel, one of the goroutines will pick it up and work on in. This is a typical worker-pool implementation.

Then, then scanner reads input line by line, and sends it to the urls channel, where one of the goroutines will pick it up and write the response to the results channel. At this point, there are no other goroutines reading from the results channel, so this will block.

As the scanner reads URLs, all other goroutines will pick them up and block. So if the scanner reads more than 20 URLs, it will deadlock because all goroutines will be waiting for a reader.

If there are fewer than 20 URLs, the scanner for-loop will end, and the results will be read. However that will eventually deadlock as well, because the for-loop will terminate when the channel is closed, and there is no one there to close the channel.

To fix this, first, close the urls channel right after you finish reading. That will release all the for-loops in the goroutines. Then you should put the for-loop reading from the results channel into a goroutine, so you can call wg.Wait while results are being processed. After wg.Wait, you can close the results channel.

This does not guarantee that all items in the results channel will be read. The program may terminate before all messages are processed, so use a third channel which you close at the end of the goroutine that reads from the results channel. That is:

done:=make(chan struct{})
go func() {
defer close(done)
for result := range results {
fmt.Printf("%s arrived\n", result)
}
}()
wg.Wait()
close(results)
<-done

I am not super happy with previous answers, so here is a solution based on the documented behavior in the go tour, the go doc, the specifications.

package main

import (
	"bufio"
	"fmt"
	"strings"
	"sync"
	"time"
)

var wg sync.WaitGroup

func sad(url string) string {
	fmt.Printf("gonna sleep a bit\n")
	time.Sleep(2 * time.Millisecond)
	return url + " added stuff"
}

func main() {
	// sc := bufio.NewScanner(os.Stdin)
	sc := bufio.NewScanner(strings.NewReader(strings.Repeat("blah blah\n", 15)))
	urls := make(chan string)
	results := make(chan string)

	for i := 0; i < 20; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			for url := range urls {
				n := sad(url)
				results <- n
			}
		}()
	}
	// results is consumed by so many goroutines
	// we must wait for them to finish before closing results
	// but we dont want to block here, so put that into a routine.
	go func() {
		wg.Wait()
		close(results)
	}()

	go func() {
		for sc.Scan() {
			url := sc.Text()
			urls <- url
		}
		close(urls) // done consuming a channel, close it, right away.
	}()

	for result := range results {
		fmt.Printf("%s arrived\n", result)
	} // the program will finish when it gets out of this loop.
	// It will get out of this loop because you have made sure the results channel is closed.

}