How to Close the goroutine which waiting on I/O

I have created two go routines sender and receiver, sender will continuous get the data from the user(keyboard) and write to stream, receiver will independently get the value from stream print it to the screen. Both are concurrent using go routine

At some point of time receiver failed and close the connection as well as exit the receiver go routine, but sender go routine which waiting for user input(i/o operation) will not be closed. How to exit all the go routines in this scenario?

Below is the piece of sample code for this scenario.

package main

import (
    "fmt"
    "time"
)

var stop bool = false

func sender() {
    str := ""
    for !stop {
        fmt.Scanf("%s", &str)
        fmt.Println("Entered :", str)
    }   
    fmt.Println("Closing sender goroutine")
}

func receiver() {
    i := 0
    for !stop {
        i++
        if i > 5 { 
            stop = true
        }
        time.Sleep(1 * time.Second)
    }   
    fmt.Println("Closing receiver goroutine")
}

func main() {
    go sender()
    go receiver()

    /* Wait for goroutines to finish */
    for !stop {
        time.Sleep(1 * time.Millisecond)
    }   
    time.Sleep(1 * time.Second)

    panic("Display stack")
}

Above code sender will wait for user input after 5 loop receiver will exit the receiver go routine. I expect when receiver close, go routine which waiting on i/o has to be closed.

Kindly help me on this question.

As Dave C & JimB say, use channels to coordinate goroutines. Here's an example that may help.

Exit after receiving 5 messages from the user:

package main

import "fmt"

var pipe = make(chan string) //shares text entered by user
var stop = make(chan bool)   //shares stop signal

func listen() {
	for {
		var input string
		fmt.Scan(&input)
		pipe <- input
	}
}

func write() {
	for i := 0; i < 5; i++ {
		var output string
		output = <-pipe
		fmt.Println("Received", output)
	}

	stop <- true
}

func main() {
	go listen()
	go write()

	<-stop
}

To start, your code has a race around the stop variable. When there's a data race, there's no guarantee your program will behave as defined. Use channels to synchronize goroutines. This however isn't why you program continues.

Your code is blocking on fmt.Scanf, and doesn't get to check the stop condition. Since a Read on Stdin can't be interrupted (which is happening inside fmt.Scanf), you need to check for the stop condition before calling Scanfagain. If there's no more input, but you have a pending Read on Stdin, the easiest way to handle it is to just let leave that goroutine running. There are some rather complex ways to break out of this using something known as the "self-pipe" trick, but it's generally not worth the effort, as goroutines are small and don't take many resources.

for {
    fmt.Scanf("%s", &str)
    fmt.Println("Entered :", str)
    // use a channel or context to detect when to exit
    select {
    case <-ctx.Done():
        return
    default:
    }
}