如何在 Golang 中使用互斥锁（mutex）锁定函数并发送响应？

编程并不是一个机械性的工作，而是需要有思考，有创新的工作，语法是固定的，但解决问题的思路则是依靠人的思维，这就需要我们坚持学习和更新自己的知识。今天golang学习网就整理分享《如何在 Golang 中使用互斥锁（mutex）锁定函数并发送响应？》，文章讲解的知识点主要包括，如果你对Golang方面的知识点感兴趣，就不要错过golang学习网，在这可以对大家的知识积累有所帮助，助力开发能力的提升。

我有这个功能。

func (s *eS) Post(param *errorlogs.Q) (*errorlogs.Error, *errors.RestErr) {
    //sub := q.Get("sub")
    s.mu.Lock()
    utime := int32(time.Now().Unix())

    // Open our jsonFile
    jsonFile, errFile := getlist(param.Id)
    // if we os.Open returns an error then handle it
    if errFile != nil {
        return nil, errFile
    }

    jsonFile, err := os.Open(dir + "/File.json")
    // if we os.Open returns an error then handle it
    if err != nil {
        return nil, errors.NewNotFoundError("Bad File request")
    }
    // read our opened jsonFile as a byte array.
    byteValue, _ := ioutil.ReadAll(jsonFile)
    // we initialize our  model
    var errorFile errorlogs.Error_File
    // we unmarshal our byteArray which contains our
    // jsonFile's content into '' which we defined above
    json.Unmarshal(byteValue, &errorFile)
    // defer the closing of our jsonFile so that we can parse it later on
    defer jsonFile.Close()
    // An object to copy the required data from the response
    var id int32
    if len(errorFile.Error) == 0 {
        id = 0
    } else {
        id = errorFile.Error[len(errorFile.Error)-1].ID
    }

    newValue := &errorlogs.Error{
        ID:         id + 1,
        Utime:      utime,
    
    }

    errorFile.Error = append(errorFile.Error, *newValue)
    file, err := json.Marshal(errorFile)
    if err != nil {
        return nil, errors.NewInternalServerError("Unable to json marshal file")
    }
    err = ioutil.WriteFile(dir+"/File.json", file, 0644)
    if err != nil {
        return nil, errors.NewInternalServerError("Unable to write file")
    }
    s.mu.Unlock()

    return newValue, nil

}

在这里，我从并发请求中锁定此函数，如果某个客户端已经写入该文件，则不会让其他客户端同时写入该文件。但现在我很困惑，这个 mutex.lock() 在锁定时对所有其他请求做了什么？它会让其他客户端等待吗？或者它只是忽略所有其他客户端？我们有什么办法给客户发回某种回复吗？或者让其他客户端等待然后允许他们访问此功能？

正确答案

当互斥锁被锁定时，对 Mutex.Lock() 的所有其他调用都将阻塞，直到首先调用 Mutex.Unlock()。

因此，当您的处理程序正在运行（并持有互斥锁）时，所有其他请求都将在 lock() 调用处被阻止。

注意：如果您的处理程序由于您提前返回（使用 return 语句）而无法正常完成，或者出现紧急情况，您的互斥锁将保持锁定状态，因此所有进一步的请求都将被阻止。

一个好的做法是在锁定互斥体后立即使用 defer 来解锁它：

s.mu.lock()
defer s.mu.unlock()

这可以确保无论函数如何结束（可能正常结束、返回或恐慌），都会调用 unlock()。

尝试保持锁的时间尽可能短，以尽量减少其他请求的阻塞时间。虽然在进入处理程序时锁定权限并仅在返回之前解锁可能很方便，但如果您在处理程序的“生命周期”内不使用受保护的资源，则仅在使用共享资源时才锁定和解锁。例如，如果您想保护对文件的并发访问，请锁定互斥体，读/写文件，并在完成后立即解锁互斥体。您对读取数据的处理方式以及如何组装和发送响应不应阻止其他请求。当然，当使用 defer 解锁时，可能不会尽早运行（当您完成共享资源时）。因此，在某些情况下，不使用 defer 可能没问题，或者访问共享资源的代码可能会移动到命名或未命名（匿名）函数，以便仍然能够使用 defer。

sync.Mutex 不支持“窥视”状态，也不支持“尝试锁定”操作。这意味着使用 sync.mutex 无法向客户端发出信号表明它必须等待，因为处理请求正在等待另一个请求完成。如果您需要这样的功能，可以使用 channels。容量为 1 的缓冲通道可以实现此功能：“锁定”操作是在通道上发送一个值，“解锁”操作是从通道接收一个值。渠道。到目前为止，一切都很好。 “try-lock”操作可能是一个“条件”发送操作：使用带有 default 情况的 select 语句，您可以检测到您现在无法锁定，因为它已经被锁定，并且您可以替代或同时执行其他操作，稍后重试锁定。

这是一个示例：

var lock = make(chan struct{}, 1)

func handler(w http.responsewriter, r *http.request) {
    // try locking:
    select {
    case lock <- struct{}{}:
        // success: proceed
        defer func() { <-lock }() // unlock deferred
    default:
        // another handler would block us, send back an "error"
        http.error(w, "try again later", http.statustoomanyrequests)
        return
    }

    time.sleep(time.second * 2) // simulate long computation
    io.writestring(w, "done")
}

func main() {
    http.handlefunc("/", handler)
    log.fatal(http.listenandserve(":8080", nil))
}

如果另一个请求持有锁，上面的简单示例将立即返回错误。您可以选择在这里做不同的事情：您可以将其放入循环中并重试几次，然后放弃并返回错误（在迭代之间稍微休息一下）。您可以在尝试锁定时使用超时，并且仅在一段时间内无法获得锁定时才接受“失败”（请参阅​​ time.After() 和 context.WithTimeout()）。当然，如果我们使用某种超时，则必须删除 default 情况（如果其他情况都无法立即进行，则立即选择 default 情况）。

当我们处理这个问题时（超时），由于我们已经在使用 select，因此我们可以合并监视请求的上下文，这是一个额外的好处：如果请求被取消，我们应该提前终止并返回。我们可以通过添加一个从上下文的完成通道接收的案例来实现这一点，例如 case <-r.context().done():。

下面是如何使用 select 简单地完成超时和上下文监控的示例：

var lock = make(chan struct{}, 1)

func handler(w http.ResponseWriter, r *http.Request) {
    // Wait 1 sec at most:
    ctx, cancel := context.WithTimeout(r.Context(), time.Second) 
    defer cancel()

    // Try locking:
    select {
    case lock <- struct{}{}:
        // Success: proceed
        defer func() { <-lock }() // Unlock deferred
    case <-ctx.Done():
        // Timeout or context cancelled
        http.Error(w, "Try again later", http.StatusTooManyRequests)
        return
    }

    time.Sleep(time.Second * 2) // Simulate long computation
    io.WriteString(w, "Done")
}

好了，本文到此结束，带大家了解了《如何在 Golang 中使用互斥锁（mutex）锁定函数并发送响应？》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多Golang知识！