Go propose trois types de verrouillage dans la programmation simultanée fonctionnelle : le verrouillage mutex (Mutex), le verrouillage en lecture-écriture (RWMutex) et le verrouillage unique (Once). Les verrous mutex garantissent un accès exclusif, les verrous en lecture-écriture autorisent des lectures simultanées et des écritures uniques, et les verrous à usage unique garantissent qu'un bloc de code n'est exécuté qu'une seule fois. Ces verrous sont utilisés pour coordonner l’accès aux ressources partagées et empêcher les courses aux données. En pratique, les mutex assurent la cohérence des données dans les services Web concurrents, empêchant les requêtes concurrentes de modifier simultanément les structures de données partagées.
Dans la programmation simultanée fonctionnelle Go, les verrous sont un mécanisme de synchronisation utilisé pour coordonner l'accès aux ressources partagées et empêcher la concurrence des données. Go propose plusieurs types de verrous, chacun avec des caractéristiques différentes et des scénarios applicables.
Mutex est un verrou de base qui ne peut permettre qu'à une seule goroutine d'obtenir des ressources en même temps. Il garantit un accès exclusif aux ressources partagées.
import ( "sync" "fmt" ) var ( mu sync.Mutex counter int ) func main() { for i := 0; i < 1000; i++ { go func() { mu.Lock() counter++ mu.Unlock() }() } fmt.Println("Final counter value:", counter) }
Le verrouillage en lecture-écriture (RWMutex) permet à plusieurs goroutines de lire les ressources partagées simultanément, mais une seule goroutine peut écrire des ressources en même temps.
import ( "sync" "fmt" ) var ( rwmu sync.RWMutex shared []int ) func main() { // 多个 goroutine 并发读取共享切片 for i := 0; i < 1000; i++ { go func() { rwmu.RLock() fmt.Println("Read:", shared) rwmu.RUnlock() }() } // 单独的 goroutine 写入共享切片 go func() { rwmu.Lock() shared = append(shared, 1, 2, 3) rwmu.Unlock() }() }
Once est un verrou unique utilisé pour garantir qu'un bloc de code spécifique n'est exécuté qu'une seule fois.
import ( "sync" "fmt" ) var ( initOnce sync.Once inited = false ) func initialize() { inited = true fmt.Println("Initialized") } func main() { initOnce.Do(initialize) if inited { fmt.Println("Already initialized") } else { fmt.Println("Not initialized") } }
Supposons qu'il existe un service Web dans lequel plusieurs requêtes simultanées doivent fonctionner sur la même structure de données partagée. Pour garantir la cohérence des données, des verrous mutex peuvent être utilisés pour protéger la structure des données et empêcher les demandes simultanées de la modifier en même temps.
import ( "sync" "net/http" ) var ( mu sync.Mutex clients map[string]*http.Client ) func main() { http.HandleFunc("/addClient", func(w http.ResponseWriter, r *http.Request) { mu.Lock() clients[r.FormValue("name")] = &http.Client{} mu.Unlock() }) }
Dans cet exemple, l'utilisation d'un mutex mu
保护对 clients
l'accès simultané à la carte garantit qu'une seule requête peut ajouter ou modifier les informations client en même temps, évitant ainsi les courses de données.
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!