Mastering Synchronization Primitives in Go

mu.Lock()
defer mu.Unlock()

// define a channel of size 2, which can buffer a maximum two numbers
numbers := make(chan int, 2)

data := []int{1, 2, 3, 4}
for x := range data {
   select {
   case numbers <- x:
      fmt.Println("wrote value", x)
   default:
      fmt.Println("didn't write since channel is full")
   }
}

/*
   Output:
   wrote value 0
   wrote value 1
   didn't write since channel is full
   didn't write since channel is full
*/

channel := make(chan int)
​
// Attempt a non-blocking read from our channel
select {
case val := <-channel:
 fmt.Println("value in chan is ", val)
default:
 fmt.Println("No value in channel")
}
​
// Output:
// No value in channel

channelA := make(chan int)
channelB := make(chan int)
​
// Attempt a non-blocking read from our channel
go func() {
   select {
   case valA := <-channelA:
      fmt.Println("value from ChannelA", valA)
   case valB := <-channelB:
      fmt.Println("value from ChannelB", valB)
   }
}()
​
channelA <- 1
time.Sleep(1)

func manualConsumer(channel chan int) {
   for {
      val, ok := <-channel
      if !ok {
          break
      }
      fmt.Println("1: read value from channel val", val)
   }
   fmt.Println("1: channel is closed")
}
​
func forRangeConsumer(channel chan int) {
   for val := range channel {
      fmt.Println("2: read value from channel val", val)
   }
   fmt.Println("2: channel is closed")
}
​
func main() {
   numbers := make(chan int)
​
   // Spawn two consumers
   go manualConsumer(numbers)
   go forRangeConsumer(numbers)
​
   // write all data into channel
   data := int{1, 2, 3, 4, 5}
   for x := range data {
      numbers <- x
   }
​
   // close channel using go provided 'close' function 
   // to indicate the end of data to consumers.
   close(numbers)
​
   // Give some time for consumer routines to exit
   // we can do this more beautifully with use of waitGroups 
   // but for simplicity sake use sleep
   time.Sleep(1)
}

func worker(wg *sync.WaitGroup) {
   fmt.Println("working ...")
   wg.Done()
}
​
func main() {
   wg := sync.WaitGroup{}
   for i := 0; i < 5; i++ {
      wg.Add(1)
      go worker(&wg)
   }
​
   fmt.Println("I am doing some work")
   wg.Wait()
}

func doTask(workerID int, taskName string) {
   fmt.Printf("worker %d is doing task %s\n", workerID, taskName)
   taskDuration := time.Duration(rand.Intn(5))
   time.Sleep(taskDuration) // represents work workerID doing taskName
}
​
func notifyOrWaitForOthers(workerID int, sharedCounter *int, cond *sync.Cond) {
   cond.L.Lock()
   defer cond.L.Unlock()
 
   // Worker has finished his job so decrements the shared counter
   *sharedCounter--
​
   // You are the last to complete the task, best notify the rest of the workers.
   if *sharedCounter == 0 {
      fmt.Printf("worker %d is the last to complete work\n", workerID)
      fmt.Printf("last worker signals all workers that they can now proceed with next task\n")
      cond.Broadcast()
      return
   }

   // You finished early, let's wait till the rest are done.
   /*
      Wait is a special function. Three things will happen upon calling it
      1. cond.L.Unlock will be called
      2. scheduler will switch to a different routine and will run it
      3. Before the wait call returns, cond.L.Lock will be called.
   */
   cond.Wait()
}
​
func worker(workerID int, sharedCounter *int, cond *sync.Cond, wg *sync.WaitGroup) {
​
   // All workers start on task A
   doTask(workerID, "A")
​
   // Once task A is done, you either wait for others or if your the last
   // to complete the task notify the rest they can start working on task B
   notifyAllOrWaitForOthers(workerID, sharedCounter, cond)
​
   // All workers start on task B
   doTask(workerID, "B")
​
   wg.Done()
}
​
func main() {
   var (
      mu            = &sync.Mutex{}
      cond          = sync.NewCond(mu)
      wg            = &sync.WaitGroup{}
      numWorkers    = 3
      sharedCounter = &numWorkers
   )
​
   wg.Add(numWorkers)
   for i := 0; i < numWorkers; i++ {
      go worker(i, &activelyWorking, cond, wg)
   }
   wg.Wait()
}