同步之sync.Mutex互斥锁

2019独角兽企业重金招聘Python工程师标准>>>

同步之sync.Mutex互斥锁

sync包中定义了Locker结构来代表锁。

type Locker interface {
    Lock()
    Unlock()
}

并且定义了两个结构来实现Locker接口：Mutex 和 RWMutex。

我们可以用一个容量只有1的channel来保证最多只有一个goroutine在同一时刻访问一个共享变量。一个只能为1和0的信号量叫做二元信号量(binary semaphore)。使用二元信号量实现互斥锁，示例如下，

var (
	// 一个二元信号量
	// 缓存为 1 的channel
	sema    = make(chan struct{}, 1) // a binary semaphore guarding balance
	balance int
)

func Deposit(amount int) {
	// 存钱的时候需要获取一个信号量，以此来保护变量 balance
	sema <- struct{}{} // acquire token
	balance = balance + amount
	<-sema // release token
}

func Balance() int {
	sema <- struct{}{} // acquire token
	b := balance
	<-sema // release token
	return b
}

使用互斥锁sync.Mutex实现示例如下，

import (
	"sync"
)

var (
	mu      sync.Mutex // guards balance
	balance int
)

func Deposit(amount int) {
	mu.Lock()
	balance = balance + amount
	mu.Unlock()
}

func Balance() int {
	mu.Lock()
	b := balance
	mu.Unlock()
	return b
}

Go语言里的sync.Mutex和Java里的ReentrantLock都实现互斥的语义，但有一个很大的区别就是锁的可重入性。

ReentrantLock 意味着什么呢？简单来说，它有一个与锁相关的获取计数器，如果拥有锁的某个线程再次得到锁，那么获取计数器就加1，然后锁需要被释放两次才能获得真正释放。这模仿了 synchronized 的语义；如果线程进入由线程已经拥有的监控器保护的 synchronized 块，就允许线程继续进行，当线程退出第二个（或者后续） synchronized 块的时候，不释放锁，只有线程退出它进入的监控器保护的第一个 synchronized 块时，才释放锁。

ReentrantLock的可重入性用代码来表示如下，

class Parent {
	protected Lock lock = new ReentrantLock();

	public void test() {
		lock.lock();
		try {
			System.out.println("Parent");
		} finally {
			lock.unlock();
		}

	}
}

class Sub extends Parent {

	@Override
	public void test() {
		lock.lock();
		try {
			super.test();
			System.out.println("Sub");
		} finally {
			lock.unlock();
		}
	}
}

public class AppTest {
	public static void main(String[] args) {
		Sub s = new Sub();
		s.test();
	}
}

要注意到需要做两次释放锁的操作。

而Go语言的sync.Mutex互斥锁没有可重入的特性，看下面这段代码，

import (
	"sync"
)

var (
	mu      sync.Mutex // guards balance
	balance int
)

func Deposit(amount int) {
	mu.Lock()
	balance = balance + amount
	mu.Unlock()
}

func Balance() int {
	mu.Lock()
	b := balance
	mu.Unlock()
	return b
}

// NOTE: incorrect!
func Withdraw(amount int) bool {
	mu.Lock()
	defer mu.Unlock()
	Deposit(-amount)
	if Balance() < 0 {
		Deposit(amount)
		return false // insufficient funds
	}
	return true
}

上面这个例子中，Deposit会调用mu.Lock()第二次去获取互斥锁，但因为mutex已经锁上了，而无法被重入——也就是说没法对一个已经锁上的mutex来再次上锁--这会导致程序死锁，没法继续执行下去，Withdraw会永远阻塞下去。

一个通用的解决方案是将一个函数分离为多个函数，比如我们把Deposit分离成两个：一个不导出的函数deposit，这个函数假设锁总是会被保持并去做实际的操作，另一个是导出的函数Deposit，这个函数会调用deposit，但在调用前会先去获取锁。同理我们可以将Withdraw也表示成这种形式：

func Withdraw(amount int) bool {
    mu.Lock()
    defer mu.Unlock()
    deposit(-amount)
    if balance < 0 {
        deposit(amount)
        return false // insufficient funds
    }
    return true
}

func Deposit(amount int) {
    mu.Lock()
    defer mu.Unlock()
    deposit(amount)
}

// This function requires that the lock be held.
func deposit(amount int) { balance += amount }

=========END=========

转载于:https://my.oschina.net/xinxingegeya/blog/717716