Go lang中的线程同步

I want to understand a bit more about how synchronisation of threads works in go. Below here I've have a functioning version of my program which uses a done channel for syncronization.

package main

import (
    . "fmt"
    "runtime"
)

func Goroutine1(i_chan chan int, done chan bool) {
    for x := 0; x < 1000000; x++ {
        i := <-i_chan
        i++
        i_chan <- i
    }
    done <- true
}
func Goroutine2(i_chan chan int, done chan bool) {
    for x := 0; x < 1000000; x++ {
        i := <-i_chan
        i--
        i_chan <- i
    }
    done <- true
}

func main() {
    i_chan := make(chan int, 1)
    done := make(chan bool, 2)
    i_chan <- 0

    runtime.GOMAXPROCS(runtime.NumCPU())
    go Goroutine1(i_chan, done)
    go Goroutine2(i_chan)
    <-done
    <-done
    Printf("This is the value of i:%d
", <-i_chan)
}

However when I try to run it with out any synchronisation. Using a wait statement and no channel to specify when it's done so no synchronisation.

const MAX = 1000000

func Goroutine1(i_chan chan int) {
    for x := 0; x < MAX-23; x++ {
        i := <-i_chan
        i++
        i_chan <- i
    }
}

func main() {
    i_chan := make(chan int, 1)
    i_chan <- 0
    runtime.GOMAXPROCS(runtime.NumCPU())
    go Goroutine1(i_chan)
    go Goroutine2(i_chan)
    time.Sleep(100 * time.Millisecond)
    Printf("This is the value of i:%d
", <-i_chan)
}

It'll print out the wrong value of i. If you extend the wait for let say 1 sec it'll finish and print out the correct statement. I kind of understand that it has something with both thread not being finished before you print what's on the i_chan I'm just a bit curious about how this works.

Note that your first example would deadlock, since it never calls GoRoutine2 (the OP since edited the question).
If it calls GoRoutine2, then the expected i value is indeed 0.

Without synchronization, (as in this example), there is no guarantee that the main() doesn't exit before the completion of Goroutine1() and Goroutine2().
For a 1000000 loop, a 1 millisecond wait seems enough, but again, no guarantee.

func main() {
    i_chan := make(chan int, 1)
    i_chan <- 0
    runtime.GOMAXPROCS(runtime.NumCPU())
    go Goroutine2(i_chan)
    go Goroutine1(i_chan)
    time.Sleep(1 * time.Millisecond)
    Printf("This is the value of i:%d
", <-i_chan)
}

see more at "How to Wait for All Goroutines to Finish Executing Before Continuing", where the canonical way is to use the sync package’s WaitGroup structure, as in this runnable example.