How can we use channels in Go in place of mutex?

Question

Channels combine communication—the exchange of a value—with synchronization—guaranteeing that two calculations (goroutines) are in a known state.

How is it possible to use the channels in Google Go to perform the functionality of mutex?

package main

import "sync"

var global int = 0
var m sync.Mutex

func thread1(){
    m.Lock()
    global = 1
    m.Unlock()
}

func thread2(){
    m.Lock()
    global = 2
    m.Unlock()
}

func main(){
   go thread1()
   go thread2()
}

Answer 1

An example of using a Channel as a Mutex:

package main

var global int = 0
var c = make(chan int, 1)

func thread1(){
    <-c // Grab the ticket
    global = 1
    c <- 1 // Give it back
}

func thread2(){
    <-c
    global = 2
    c <- 1
}

func main() {
   c <- 1 // Put the initial value into the channel
   go thread1()
   go thread2()
}

You could also use chan struct{} instead of chan int to reduce the memory size. The value that goes into it is struct{}{} (type struct{} and an empty content {}). See Ivan black's comment for an example.

Answer 2

If you have a channel c that you initialize with 1 item in it, then you can "check out" the "mutex" by removing the value from the channel (<-c). You can "release" it by adding the value back (c <- 1).

Since the extract-from-channel operator a) is atomic, and b) blocks until there's something to extract, it works as a mutex, since if one thread of execution already has it checked out, there will be nothing in the channel, and thus it will block until the thread that had it checked out returns a value to the channel for another thread to extract.