php小编草莓将为您介绍如何解决共享资源的访问冲突问题。在多线程或多进程编程中，当多个线程或进程同时访问共享资源时，可能会导致数据不一致或错误的结果。为了解决这个问题，可以使用互斥锁、信号量、条件变量等同步机制来保证资源的互斥访问。通过合理使用这些同步机制，我们可以有效地解决共享资源的访问冲突问题，保证程序的正确性和稳定性。
问题内容
有一个测试服务有 2 个请求。这些请求使用 actualorders 变量形式的共享资源。假设正在运行数百个并行查询，则 actualorders 变量中可能会发生数据冲突。特别是当我循环遍历数组时。为了防止这种情况，使用 mutex 是否足够，就像我在下面的示例中所做的那样？
main.go：
package main
import (
"encoding/json"
"errors"
"fmt"
"net/http"
"os"
"time"
)
type Order struct {
Room string `json:"room"`
UserEmail string `json:"email"`
From time.Time `json:"from"`
To time.Time `json:"to"`
}
var ActualOrders = []Order{}
var mutex sync.Mutex
func getOrders(responseWriter http.ResponseWriter, request *http.Request) {
userEmail := request.URL.Query().Get("email")
results := []Order{}
mutex.Lock()
for _, item := range ActualOrders {
if item.UserEmail == userEmail {
results = append(results, item)
}
}
mutex.Unlock()
bytes, err := json.Marshal(results)
if err != nil {
http.Error(responseWriter, err.Error(), http.StatusInternalServerError)
return
}
responseWriter.Header().Set("Content-type", "application/json")
responseWriter.WriteHeader(http.StatusOK)
responseWriter.Write(bytes)
}
func createOrder(responseWriter http.ResponseWriter, request *http.Request) {
var newOrder Order
requestBody := request.Body
defer request.Body.Close()
err := json.NewDecoder(requestBody).Decode(&newOrder)
if err != nil {
http.Error(responseWriter, err.Error(), http.StatusBadRequest)
return
}
mutex.Lock()
for _, order := range ActualOrders {
if !(newOrder.To.Before(order.From) || newOrder.From.After(order.To)) {
http.Error(responseWriter, http.StatusText(http.StatusConflict), http.StatusConflict)
return
}
}
ActualOrders = append(ActualOrders, newOrder)
mutex.Unlock()
responseWriter.WriteHeader(http.StatusCreated)
}
func main() {
mux := http.NewServeMux()
mux.HandleFunc("/orders", getOrders)
mux.HandleFunc("/order", createOrder)
err := http.ListenAndServe(":8080", mux)
if errors.Is(err, http.ErrServerClosed) {
fmt.Printf("server closed\n")
} else if err != nil {
fmt.Printf("error starting server: %s\n", err)
os.Exit(1)
}
}解决方法
像您一样使用互斥锁可以防止数据争用。不过，您的实施还可以改进。
您可以使用 rwmutex，对 getorders 函数使用读锁，对 createorder 函数使用锁。这将允许在写入时对 actualorders 变量进行独占访问，但允许共享读取：
var mutex sync.RWMutex
func getOrders(responseWriter http.ResponseWriter, request *http.Request) {
...
mutex.RLock()
...
mutex.RUnlock()
}
func createOrder(responseWriter http.ResponseWriter, request *http.Request) {
...
mutex.Lock()
for _, order := range ActualOrders {
...
}
ActualOrders = append(ActualOrders, newOrder)
mutex.Unlock()
} 
