Why do Go programs encounter the \"fatal error: all goroutines are asleep - deadlock!\" and how can it be fixed?

Go: Deadlock Panic - Understanding the Cause and Fixing It

In Go, a common error encountered is "fatal error: all goroutines are asleep - deadlock!" when attempting to manage communication between goroutines. This error arises when goroutines become stuck in a state where they are all waiting for each other to proceed.

Problem Statement

Consider the following code where you aim to read a line of words from a text file, store them in a channel, and then print them individually:

func main() {
    f, _ := os.Open("D:\input1.txt")
    scanner := bufio.NewScanner(f)
    file1chan := make(chan string)
    for scanner.Scan() {
        line := scanner.Text()
        parts := strings.Fields(line)
        for i := range parts {
            file1chan <- parts[i]
        }
    }
    print(file1chan)
}

func print(in <-chan string) {
    for str := range in {
        fmt.Printf("%s\n", str)
    }
}

Cause of the Deadlock

Upon running this code, you encounter the deadlock error. This occurs because the channel file1chan is unbuffered. As a result, when you attempt to send a value into the channel, it blocks indefinitely, waiting for a receiver.

Fixing the Deadlock

To resolve the deadlock, you have two options:

1. Use a Buffered Channel:
   You can create a buffered channel by specifying its size as the second argument to make(chan), like this:

   file1chan := make(chan string, 1) // buffer size of one

   A buffered channel acts like an array, where the sender can send values without blocking if the channel has available capacity.

2. Use a New Goroutine:
   You can start a new goroutine to send values to the unbuffered channel:

   file1chan := make(chan string)
   go func() { // start a new goroutine that sends strings down file1chan
       for scanner.Scan() {
           line := scanner.Text()
           parts := strings.Fields(line)
           for i := range parts {
               file1chan <- parts[i]
           }
       }
       close(file1chan)
   }()
   
   print(file1chan)

   With this approach, the new goroutine assumes the responsibility of sending values, while the main goroutine focuses on printing them.

By implementing either of these solutions, you effectively eliminate the deadlock and enable smooth communication between your goroutines.

The above is the detailed content of Why do Go programs encounter the \"fatal error: all goroutines are asleep - deadlock!\" and how can it be fixed?. For more information, please follow other related articles on the PHP Chinese website!