learned! Use buffered channels as Mutexes

As part of the official Go package, the sync package has the following statement:

The sync package provides basic synchronization primitives such as mutex locks. Except for the Once and WaitGroup types, most other types are intended for the underlying function library. Higher level synchronization is better accomplished through channels and communications.

In the vast majority of examples you can find of allowing concurrent access, many use mutexes to solve the problem. However, there are few examples showing us how to use channels to provide synchronization mechanisms. So, let’s discuss it in this article.

Characteristics of mutex locks

In order for the mutex lock to work, you need to lock it when accessing the shared variable, and you need to unlock it after the operation is completed. . The same mutex is not allowed to be locked multiple times to avoid race conditions.

Unbuffered channel and its shortcomings

If there is no receiver, the sender will block; similarly, if there is no sender , the receiver will block. Based on this characteristic, we cannot use unbuffered channels as locks.

Let's see if the buffer channel can be used as a mutex lock.

Characteristics and advantages of a channel with a buffer size of 1

A channel with a buffer size of 1 has the following characteristics: If the buffer is full , it will be blocked when sending; if the cache is vacated, it will be unblocked when sending.

Obviously, the blocking characteristics of this channel are desirable. Compare it with the characteristics of mutex locks:

Lock when the buffer is full<-->

Buffer Vacation<--> Unlock

Let’s demonstrate this feature through code.

Demonstration: How to use the buffer channel as a "lock"

We assume that there is a column of names that need to be written to the file, and each name needs to be consecutive Write 1000 times, and do not allow overlap between different names.

package main
import (
 "errors"
 "fmt"
 "os"
 "sync"
)
func main() {
 file, err := os.Create("record.txt")

 defer func() {
  if err := recover(); err != nil {
   fmt.Printf("Error encounter: %w", err)
  }
  file.Close()
 }()
 if err != nil {
  panic(errors.New("Cannot create/open file"))
 }
 ss := []string{ //string slice literals
  "James",
  "Avery",
  "Peter",
  "John",
  "Beau",
 }
 chanLock := make(chan int, 1) //1
 var wg sync.WaitGroup
 for _, str := range ss { //2
  wg.Add(1) //amended thanks to response from Wang
  //Sheng
  go func(aString string) {

   chanLock <- 1 //3
   for i := 0; i < 1000; i++ {
    file.WriteString(aString + "\n")
   }
   <-chanLock //4
   wg.Done() //5
  }(str) //pass by value
 }
 wg.Wait()
}

In the above code, //1 we created a channel with a buffer of 1. //2 We created the same number of goroutines as the number of names. //3 is equivalent to locking, //4 is equivalent to unlocking, so that multiple goroutines can write names to the record.txt file synchronously, but only one goroutine will operate the file at a time.

It should be noted that we use WaitGroup to ensure that the main coroutine will not exit before the sub-goroutine completes the task.

Hope this article is helpful to you, enjoy coding!