Threads from java to go

How can I translate the below code to Go, you can see my attempt below but because I'm waiting for a key input the code will always return 20000 where java will output different results. I know that both have a race condition, but I just want to know the translation.

JAVA

public class Counting {
    public static void main(String[] args) throws InterruptedException {
	  class Counter {
		private int count = 0;
		public void increment() { ++count; }
		public int getCount() { return count; }
	  }
	final Counter counter = new Counter();
	
	class CountingThread extends Thread {
		public void run() {
			for(int x = 0; x < 10000; ++x)
				counter.increment();	
		}
	}
	
	CountingThread t1 = new CountingThread();
	CountingThread t2 = new CountingThread();
	t1.start(); t2.start();
	t1.join(); t2.join();
	System.out.println(counter.getCount());
  }
}

Here is my go attempt:

import (
  "fmt"
)

type Counting struct {
  count int
}

var counter = Counting{}

func (c *Counting) increment() {
  c.count++
}

func (c *Counting) getCount() int {
  return c.count
}

func CountingThread() {
  for i := 0; i < 10000; i++ {
	counter.increment()
  }
}

func main() {
  go CountingThread()
  go CountingThread()
  var input string
  fmt.Scanln(&input)
  fmt.Println(counter.getCount())
}

Goroutines are not threads, so a synchronization primitive must be used.

Your translation should be done using a sync.WaitGroup (see http://golang.org/pkg/sync/#WaitGroup).

package main

import (
	"fmt"
	"sync"
)

type Counting struct {
	count int
}

var counter = Counting{}

func (c *Counting) increment() {
	c.count++
}

func (c *Counting) getCount() int {
	return c.count
}

func CountingThread(wg *sync.WaitGroup) {
	for i := 0; i < 10000; i++ {
		counter.increment()
	}
	wg.Done() // mark the goroutine as finished
}

func main() {
	var wg sync.WaitGroup

	wg.Add(2) // we know we'll wait for 2 goroutines

	go CountingThread(&wg)
	go CountingThread(&wg)

	wg.Wait() // wait for the goroutines to both finish

	fmt.Println(counter.getCount())
}

Demonstration here: http://play.golang.org/p/0SHCvowDjI

It outputs the "expected" value of 20000.

Obviously this code demonstrates a data race:

$ go run -race race.go 
==================
WARNING: DATA RACE
Read by goroutine 6:
  main.CountingThread()
      race.go:24 +0x48

Previous write by goroutine 7:
  main.CountingThread()
      race.go:24 +0x5e

Goroutine 6 (running) created at:
  main.main()
      race.go:34 +0x8f

Goroutine 7 (running) created at:
  main.main()
      race.go:35 +0xb1
==================
19042
Found 1 data race(s)
exit status 66

This can be solved by the use of an atomic counter:

type Counting struct {
        count int32
}

var counter = Counting{}

func (c *Counting) increment() {
        atomic.AddInt32(&c.count, 1)
}

func (c *Counting) getCount() int32 {
        return atomic.LoadInt32(&c.count)
}

See demo at http://play.golang.org/p/68FkSWt6rw.