Go language - lock operation

summary

sync Package document ：Package sync - The Go Programming Language

sync Packages provide basic synchronization operations , Such as mutual exclusion lock . except Once and WaitGroup outside , Most types are used by low-level library routines . The more advanced synchronization is better through channel And communication .

The mutex Mutex

Mutexes are more violent , When one goroutine After obtaining the mutex , Other goroutine You can only wait for the lock to be released .

When using mutex , You must unlock the resource after the operation , Otherwise the program will deadlock . It is recommended to use defer Statement to unlock .

// Define mutex objects 
var mutex_name sync.Mutex

// locked 
mutex_name.Lock()
// Unlock 
mutex_name.Unlock()

The same is the problem of ticket sales at the railway station , Let's take a look at the effect of solving the critical resource problem through mutual exclusion

// Ticket allowance 
var tickets = 5

// Define synchronization waiting groups 
var wg sync.WaitGroup

// Define mutex objects 
var mutex sync.Mutex

func main() {
	wg.Add(3)
	go saleTickets("1 Ticket booth No ")
	go saleTickets("2 Ticket booth No ")
	go saleTickets("3 Ticket booth No ")
	wg.Wait()
}

func saleTickets(name string) {
	for {
		mutex.Lock()
		if tickets > 0 {
			fmt.Printf(" Ticket remaining :%v, %v Sell out \n", tickets, name)
			tickets--
			time.Sleep(1 * time.Second)
		} else {
			mutex.Unlock()
			fmt.Println(" The tickets have been sold out ...")
			wg.Done()
			break
		}
		mutex.Unlock()
	}
}

 

Read-write lock RWMutex

The difference between a read-write lock and an ordinary mutex lock is , It is a kind of mutex for read and write operations .

Multiple read operations are allowed at the same time , But only one write operation is allowed at a time . And during a write operation , Read operations are also not allowed . So , Read / write locks can be concurrent for read operations , But for write operations, they are completely mutually exclusive .

// Define the read / write lock object 
var rwmutex_name sync.RWMutex

// Read the lock 
rwmutex_name.RLock
// Read unlock 
rwmutex_name.RUnlock

// Write lock 
rwmutex_name.Lock
// Write unlock 
rwmutex_name.Unlock

We will not show the example of read-write lock , Because the effect should not be different from the example shown above .

         The problem actually solved with write locks is , The use of mutexes reduces concurrency . Because mutexes block both read and write operations , The program has changed from concurrent to serial .

        In fact, for read operations that do not modify critical resources , We don't need to block ; Only write operations that need to be modified for critical resources , We just need to block . So read-write locking is to improve the concurrency of programs when locking .