How to efficiently close the channel?

I'm trying to do some stuff:

type Feed struct {
	title, descr, link string
	published          time.Time
}
func main() {
	ar := make([]Feed, 0)
    for i := 0; i < 3; i++ {
        f: = new(Feed)
		// do some stuff with feed
        ar = append(ar, *f)
	}

	ch := make(chan Feed, 3)

    for _, i := range ar {
        go process(i, ch)
    }

	r :=0
	for i := range ch {
		fmt.Println(i)
		r++
		if r == 3 {
			close(ch)
		}
	}
}
func process(i Feed, ch chan Feed) {
 // do some stuff
 ch <- i
}

It seems that ar is unnecessary, but if it would be removed, last range would be forever. What i'm doing wrong?

Another question is - is that way of working with Go routines the right way?

Here is an example producer-consumer type. I only use the WaitGroup here so that the main goroutine wouldn't exit instantly. Theoretically your application could either wait, or do some other interesting stuff in the mean time.

Note that you could also use a buffered channel using c := make(chan(*Feed, n)) where n is the number you want buffered. Just be aware that in a typical producer-consumer scenario, there is sometimes a lot of resources allocated per job. So depending on that you could buffer just a few, or all of them if you wanted.

Without a buffered channel, it acts as a sync between the goroutines. Producers block at c <- waiting for a consumer's <- c to hand off to, so only one of each routine execute these lines at a time.

EDIT I added a pause before printing "started" to make the output less synchronized. It previously always output:

created
started
created
started
...

https://play.golang.org/p/FmWqegr-CR

package main

import (
	"fmt"
	"math/rand"
	"sync"
	"time"
)

type Feed struct {
	title, descr, link string
	published          time.Time
}

func CreateFeed() *Feed {
	r := rand.Int() % 500
	time.Sleep(1000 + time.Duration(r)*time.Millisecond)
	fmt.Println("Feed created")
	return &Feed{
		published: time.Now(),
	}
}

func UseFeed(f *Feed) {
	time.Sleep(100 * time.Millisecond)
	fmt.Println("Feed started")
	time.Sleep(1600 * time.Millisecond)
	fmt.Printf("Feed consumed: %s\n", f.published)
}

func main() {
	numFeeds := 10

	var wg sync.WaitGroup
	wg.Add(10)

	c := make(chan (*Feed))
	for i := 0; i < numFeeds; i++ {
		go func() { c <- CreateFeed() }()
	}

	for i := 0; i < numFeeds; i++ {
		go func() {
			f := <-c
			UseFeed(f)
			wg.Done()
		}()
	}

	wg.Wait()
}

I'm hoping this is what you are looking for.