Question

我是Go的新手，我想实现一种自定义的互斥机制，每个应用程序用户可以一次执行一个goroutine。为简化起见，请将U1和U2视为应用程序用户，将F1（userId），F2（userId）和F3（userId）视为三个不同的goroutine，它们从数据库中读取/写入仅与给定用户相关的记录。我想，如果直到F1结束才执行U1调用（F1，F2，F3），（F2，F3），则执行F2或F3（按调用顺序将是最佳解决方案），最后剩下的一个被执行。 U2不受U1锁的影响，但如上所述，她受其自己的锁控制。您将如何实施？有内置的原语吗？谢谢

Answer 1

使用sync.Mutex进行互斥。为每个活动用户使用一个互斥锁。

我假设用户通过某种ID进行标识。我们将其称为userID。使用以userID键控的映射存储每个用户的互斥量。

仅活动用户才需要互斥锁，并非所有潜在用户都需要。使用整数计数器来确定用户是否处于活动状态。

上述映射和计数器也应使用互斥保护。

代码如下：

type userID string // replace userID type with id type for your application

// userLock is the per user lock
type userLock struct {
    sync.Mutex

    // n is number of goroutines between lock and unlock
    n int
}

var (
    // mu protects locks map and n field in userLock
    mu    sync.Mutex

    // locks is map of active locks
    locks = map[userID]*userLock{}
)


// lockUser locks the user specified by id. If the lock is
// already in use, the calling goroutine blocks until
// the lock is available.
func lockUser(id userID) {
    mu.Lock()
    l := locks[id]
    if l == nil {
        l = &userLock{}
        locks[id] = l
    }
    l.n++
    mu.Unlock()
    l.Lock()
}

// unlockUser unlocks the user specified by id. It 
// is a run-time error if the user is not locked on
// entry unlockUser.
func unlockUser(id userID) {
    mu.Lock()
    l := locks[id]
    if l == nil {
        panic("unlock without lock")
    }
    l.n--
    if l.n == 0 {
        delete(locks, id)
    }
    mu.Unlock()
    l.Unlock()
}

Answer 2

您可以将缓冲的通道用作信号灯，并为每个用户创建这样的通道。然后，与同一个用户相关的两个goroutine仅在获取信号量（成功写入通道）后才能执行操作。

使用Go通道作为信号灯的资源：

对goroutine的“选择性”互斥

2 个答案: