如何在 Golang 中实现带有超时功能的锁？

来到golang学习网的大家，相信都是编程学习爱好者，希望在这里学习Golang相关编程知识。下面本篇文章就来带大家聊聊《如何在 Golang 中实现带有超时功能的锁？》，介绍一下，希望对大家的知识积累有所帮助，助力实战开发！

如何才能在 go 中只尝试获取类似互斥锁的锁，要么立即中止（就像 trylock 在其他实现中所做的那样），或者通过观察某种形式的截止日期（基本上 lockbefore)?

我现在可以想到两种情况，这将非常有帮助，并且我正在寻找某种解决方案。第一个是：cpu 密集型服务，接收延迟敏感请求（例如 web 服务）。在这种情况下，您可能需要执行类似于下面的 rpcservice 示例的操作。可以将其实现为工作队列（带有通道和内容），但在这种情况下，衡量和利用所有可用的 cpu 会变得更加困难。也可以接受这样的事实：当您获得锁定时，您的代码可能已经超过了截止日期，但这并不理想，因为它浪费了一些资源，并且意味着我们无法做“降级的临时”之类的事情。响应”。

/* example 1: lockbefore() for latency sensitive code. */
    func (s *rpcservice) dothething(ctx context.context, ...) ... {
      if s.someobj[req.parameter].mtx.lockbefore(ctx.deadline()) {
        defer s.someobj[req.parameter].mtx.unlock()
        ... expensive computation based on internal state ...
      } else {
        return s.cheapcachedresponse[req.parameter]
      }
    }

另一种情况是，当你有一堆应该被触摸的对象，但它们可能被锁定，并且触摸它们应该在一定的时间内完成（例如更新一些统计数据）。在这种情况下，您还可以使用 lockbefore() 或某种形式的 trylock()，请参阅下面的统计示例。

/* Example 2: TryLock() for updating stats. */
    func (s *StatsObject) updateObjStats(key, value interface{}) {
      if s.someObj[key].TryLock() {
        defer s.someObj[key].Unlock()
        ... update stats ...
        ... fill in s.cheapCachedResponse ...
      }
    }

    func (s *StatsObject) UpdateStats() {
      s.someObj.Range(s.updateObjStats)
    }

为了便于使用，我们假设在上述情况下我们正在谈论相同的s.someobj。任何对象都可能被 dothething() 操作阻塞很长时间，这意味着我们希望在 updateobjstats 中跳过它。另外，我们希望确保在 dothething() 中返回便宜的响应，以防我们无法及时获取锁。

不幸的是，sync.mutex 仅具有 lock() 和 unlock() 函数。没有办法可能获取锁。有没有一些简单的方法可以做到这一点？我是否从一个完全错误的角度来处理这类问题，是否有一种不同的、更“可行”的方法来解决它们？或者如果我想解决这些问题，我是否必须实现自己的互斥体库？我知道问题 6123 似乎表明不存在这样的事情，而且我处理这些问题的方式完全不可行。

解决方案

我认为您在这里问了几个不同的问题：

1. 标准库中是否存在此功能？不，事实并非如此。您可能可以在其他地方找到实现 - 这可以使用标准库（例如原子）来实现。

2. 为什么标准库中不存在此功能：您在问题中提到的问题是一个讨论。 go-nuts 邮件列表上也有几位 go 代码开发人员参与的讨论：link 1、link 2。通过谷歌搜索很容易找到其他讨论。

3. 如何设计我的程序而不需要这个？

(3) 的答案更加微妙，取决于您的具体问题。你的问题已经说了

可以将其实现为工作队列（带有通道和 的东西），但在这种情况下，它变得更难以衡量和 利用所有可用的 cpu

没有详细说明为什么与检查互斥锁状态相比，利用所有 cpu 会更加困难。

在 go 中，每当锁定方案变得不平凡时，您通常都需要通道。它不应该更慢，而且应该更易于维护。

使用缓冲区大小为 1 的通道作为互斥体。

l := make(chan struct{}, 1)

锁定：

l <- struct{}{}

解锁：

<-l

尝试锁定：

select {
case l <- struct{}{}:
    // lock acquired
    <-l
default:
    // lock not acquired
}

尝试超时：

select {
case l <- struct{}{}:
    // lock acquired
    <-l
case <-time.After(time.Minute):
    // lock not acquired
}

终于介绍完啦！小伙伴们，这篇关于《如何在 Golang 中实现带有超时功能的锁？》的介绍应该让你收获多多了吧！欢迎大家收藏或分享给更多需要学习的朋友吧~golang学习网公众号也会发布Golang相关知识，快来关注吧！