Julia set image rendering ruined by concurrency

I have the following code that I am to change into a concurrent program.

// Stefan Nilsson 2013-02-27

// This program creates pictures of Julia sets (en.wikipedia.org/wiki/Julia_set).
package main

import (
	"image"
	"image/color"
	"image/png"
	"log"
	"math/cmplx"
	"os"
	"strconv"
)

type ComplexFunc func(complex128) complex128

var Funcs []ComplexFunc = []ComplexFunc{
	func(z complex128) complex128 { return z*z - 0.61803398875 },
	func(z complex128) complex128 { return z*z + complex(0, 1) },
}

func main() {
	for n, fn := range Funcs {
		err := CreatePng("picture-"+strconv.Itoa(n)+".png", fn, 1024)
		if err != nil {
			log.Fatal(err)
		}
	}
}

// CreatePng creates a PNG picture file with a Julia image of size n x n.
func CreatePng(filename string, f ComplexFunc, n int) (err error) {
	file, err := os.Create(filename)
	if err != nil {
		return
	}
	defer file.Close()
	err = png.Encode(file, Julia(f, n))
	return
}

// Julia returns an image of size n x n of the Julia set for f.
func Julia(f ComplexFunc, n int) image.Image {
	bounds := image.Rect(-n/2, -n/2, n/2, n/2)
	img := image.NewRGBA(bounds)
	s := float64(n / 4)
	for i := bounds.Min.X; i < bounds.Max.X; i++ {
		for j := bounds.Min.Y; j < bounds.Max.Y; j++ {
			n := Iterate(f, complex(float64(i)/s, float64(j)/s), 256)
			r := uint8(0)
			g := uint8(0)
			b := uint8(n % 32 * 8)
			img.Set(i, j, color.RGBA{r, g, b, 255})
		}
	}
	return img
}

// Iterate sets z_0 = z, and repeatedly computes z_n = f(z_{n-1}), n ≥ 1,
// until |z_n| > 2  or n = max and returns this n.
func Iterate(f ComplexFunc, z complex128, max int) (n int) {
	for ; n < max; n++ {
		if real(z)*real(z)+imag(z)*imag(z) > 4 {
			break
		}
		z = f(z)
	}
	return
}

I have decided to try and make the Julia() function concurrent. So I changed it to:

func Julia(f ComplexFunc, n int) image.Image {	
	bounds := image.Rect(-n/2, -n/2, n/2, n/2) 	
	img := image.NewRGBA(bounds)				
	s := float64(n / 4)							 
	for i := bounds.Min.X; i < bounds.Max.X; i++ {
		for j := bounds.Min.Y; j < bounds.Max.Y; j++ {
			go func(){
				n := Iterate(f, complex(float64(i)/s, float64(j)/s), 256)
				r := uint8(0)	
				g := uint8(0)	
				b := uint8(n % 32 * 8)	
				img.Set(i, j, color.RGBA{r, g, b, 255}) 
			}()
		}
	}
	return img 

This change causes the images to look very different. The patterns are essentially the same, but there are a lot of white pixels that were not there before.

What is happening here?

There are 2 problems:

1. You don't actually wait for your goroutines to finish.
2. You don't pass i and j to the goroutine, so they will almost always be the last i and j.

Your function should look something like:

func Julia(f ComplexFunc, n int) image.Image {
	var wg sync.WaitGroup
	bounds := image.Rect(-n/2, -n/2, n/2, n/2)
	img := image.NewRGBA(bounds)
	s := float64(n / 4)
	for i := bounds.Min.X; i < bounds.Max.X; i++ {
		for j := bounds.Min.Y; j < bounds.Max.Y; j++ {
			wg.Add(1)
			go func(i, j int) {
				n := Iterate(f, complex(float64(i)/s, float64(j)/s), 256)
				r := uint8(0)
				g := uint8(0)
				b := uint8(n % 32 * 8)
				img.Set(i, j, color.RGBA{r, g, b, 255})
				wg.Done()
			}(i, j)
		}
	}
	wg.Wait()
	return img
}

A bonus tip, when diving into concurrency, it's usually a good idea to try your code with the race detector.

You might have to use a mutex to call img.Set but I'm not very sure and I can't test atm.