CODEWITHSUNDEEP
goconcurrencyparallel-processinggoroutine
LCaraway
LCaraway

Reputation: 1357

Add items to channel in one goroutine and process in another

Really new to the world of go and trying to learn by doing. I want to see how I would use go routines to add items to a "queue" in one go routine while another go routine listens for the queue and processes things as they enter. In this case I have a func that adds a defined amount of items to a int[] while the other attempts to print them as they are added.. I assume a flag will need to be sent to signal that one go routine has stopped adding items to the queue. I apologize for the noob question but am struggling understanding the new terminology and syntax.

package main

import "fmt"


func printFromSlice(c chan []int){
    i := <-c
    // wait for item to be added to channel
    fmt.Print(i)
}

func addToSlice (c chan []int, i int)  {
    for n := 0; n < i; n++{
        c <- n //I know this isnt right
    }

    // How do we signal this is complete??
}

func main(){
    c := make(chan []int)
    //add things to []i int
    go addToSlice(c, 25)
    //do something from []int
    go printFromSlice(c)



}

  **UPDATE**

modified to use the following code however now it will only execute to a single print form the ~printFromSlice` function before it closes out...

package main

func printFromSlice(c chan int){
    i := <-c
    // wait for item to be added to channel
    println("read")
    println(i)
}

func addToSlice (c chan int)  {
    for n := 0; n < 100; n++{
        println("add")
        println(n)
        c <- n
    }

    close(c)

}

func main(){
    println("starting...")
    c := make(chan int)

    //add things to []i int
    go addToSlice(c)
    //do something from []int
    go printFromSlice(c)

    <-c


}

Upvotes: 1

Views: 924

Answers (1)

Adrian
Adrian

Reputation: 397

You need to add a sync.WaitGroup to block the main thread until the two goroutine could finish. You could refer to this Go by Example.

package main

import "sync"

func printFromSlice(c chan int, wg *sync.WaitGroup) {
    defer wg.Done() // Decrement the waitgroup counter by 1 after `printFromSlice` returns

    // wait for item to be added to channel
    // i := <-c // this only waits / blocks 1 time

    // For each message arriving at c, read and print
    for i := range c { // this would read all messages until channel is closed
        println("read")
        println(i)
    }
}

func addToSlice(c chan int, wg *sync.WaitGroup) {
    defer wg.Done() // Decrement the waitgroup counter by 1 after `addToSlice` returns

    for n := 0; n < 100; n++ {
        println("add")
        println(n)
        c <- n
    }

    close(c)

}

func main() {
    var wg sync.WaitGroup

    println("starting...")
    c := make(chan int)

    wg.Add(2) // Adds 2 to the waitgroup counter

    //add things to []i int
    go addToSlice(c, &wg) // Pass the wait group as reference so they can call wg.Done()
    //do something from []int
    go printFromSlice(c, &wg) // Pass the wait group as reference so they can call wg.Done()

    // <-c // No need for this to block the code

    wg.Wait() // Waits / blocks until waitgroup counter is 0
}

Upvotes: 2

Related Questions