From 86986ad8b302b6d14bd9d01e2cd607aeec6e62fc Mon Sep 17 00:00:00 2001 From: geolffreym Date: Fri, 10 Jun 2022 14:12:55 -0600 Subject: [PATCH 1/8] synchronization/read-write-lock: peer conenction router example implementation --- synchronization/read-write-lock.md | 110 +++++++++++++++++++++++++++++ 1 file changed, 110 insertions(+) create mode 100644 synchronization/read-write-lock.md diff --git a/synchronization/read-write-lock.md b/synchronization/read-write-lock.md new file mode 100644 index 0000000..2a94a59 --- /dev/null +++ b/synchronization/read-write-lock.md @@ -0,0 +1,110 @@ +# Read/Write Lock Pattern +Allows parallel read access, but only exclusive access on write operations to a resource + +## Implementation + +```go +package router + +import ( + "sync" +) + +type Socket string +type Peer interface { + socket Socket + connection net.Conn +} + +func (p *Peer) Socket() Socket { + return p.socket +} + +// Router hash table to associate Socket with Peers. +// Unstructured mesh architecture +// eg. {127.0.0.1:4000: Peer} +type Router struct { + sync.RWMutex + table map[Socket]Peer +} + + +// Return connection interface based on socket +func (r *Router) Query(socket Socket) *Peer { + // Mutex for reading topics. + // Do not write while topics are read. + // Write Lock can’t be acquired until all Read Locks are released. + r.RWMutex.RLock() + defer r.RWMutex.RUnlock() + + if peer, ok := r.table[socket]; ok { + return peer + } + + return nil +} + +// Add create new socket connection association +func (r *Router) Add(peer *Peer) { + // Lock write/read table while add operation + // A blocked Lock call excludes new readers from acquiring the lock. + r.RWMutex.Lock() + defer r.RWMutex.Unlock() + r.table[peer.Socket()] = peer +} + +// Delete removes a connection from router +func (r *Router) Delete(peer *Peer) { + // Lock write/read table while delete operation + // A blocked Lock call excludes new readers from acquiring the lock. + r.RWMutex.Lock() + defer r.RWMutex.Unlock() + delete(r.table, peer.Socket()) +} +``` + +## Usage +### Syncronize routing peers from incoming connections + +```go + +// New router +router:= &Router{ + table: make(map[Socket]Peer) +} + +// !Important: +// 1 - Write Lock can’t be acquired until all Read Locks are released. +// 2 - A blocked Lock call excludes new readers from acquiring the lock. + +// Writing operation +go func(r *Router){ + for { + // this will be running waiting for new connections + /// .. some code here + conn, err := listener.Accept() + // eg. 192.168.1.1:8080 + remote := connection.RemoteAddr().String() + socket := Socket(address) + // New peer + peer := &Peer{ + socket: socket, + connection: conn + } + // Here we need a write lock to avoid race condition + r.Add(peer) + } +}(router) + +// Reading operation +go func(r *Router){ + // ...some logic here + // reading operation 1 + connection := router.Query("192.168.1.1:8080") + //... more code here + // reading operation 2 + otherQuery:= router.Query("192.168.1.1:8081") + // read locks are like counters.. until counter = 0 Write can be acquired +}(router) + +``` \ No newline at end of file From 0df091d0644f787577c2666a1be72eceed5531f1 Mon Sep 17 00:00:00 2001 From: geolffreym Date: Fri, 10 Jun 2022 14:16:52 -0600 Subject: [PATCH 2/8] synchronization/read-write-lock: peer conenction router example implementation --- synchronization/read-write-lock.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/synchronization/read-write-lock.md b/synchronization/read-write-lock.md index 2a94a59..fbc6db2 100644 --- a/synchronization/read-write-lock.md +++ b/synchronization/read-write-lock.md @@ -46,7 +46,7 @@ func (r *Router) Query(socket Socket) *Peer { // Add create new socket connection association func (r *Router) Add(peer *Peer) { - // Lock write/read table while add operation + // Lock write table while add operation // A blocked Lock call excludes new readers from acquiring the lock. r.RWMutex.Lock() defer r.RWMutex.Unlock() @@ -55,7 +55,7 @@ func (r *Router) Add(peer *Peer) { // Delete removes a connection from router func (r *Router) Delete(peer *Peer) { - // Lock write/read table while delete operation + // Lock write table while delete operation // A blocked Lock call excludes new readers from acquiring the lock. r.RWMutex.Lock() defer r.RWMutex.Unlock() @@ -100,10 +100,10 @@ go func(r *Router){ go func(r *Router){ // ...some logic here // reading operation 1 - connection := router.Query("192.168.1.1:8080") + connection := r.Query("192.168.1.1:8080") //... more code here // reading operation 2 - otherQuery:= router.Query("192.168.1.1:8081") + otherQuery:= r.Query("192.168.1.1:8081") // read locks are like counters.. until counter = 0 Write can be acquired }(router) From 48d1d8039154f148ca1fcd84be92117f30c0a54a Mon Sep 17 00:00:00 2001 From: geolffreym Date: Fri, 10 Jun 2022 14:18:42 -0600 Subject: [PATCH 3/8] fix: rename file according to Summary --- synchronization/read-write-lock.md | 110 ----------------------------- 1 file changed, 110 deletions(-) delete mode 100644 synchronization/read-write-lock.md diff --git a/synchronization/read-write-lock.md b/synchronization/read-write-lock.md deleted file mode 100644 index fbc6db2..0000000 --- a/synchronization/read-write-lock.md +++ /dev/null @@ -1,110 +0,0 @@ -# Read/Write Lock Pattern -Allows parallel read access, but only exclusive access on write operations to a resource - -## Implementation - -```go -package router - -import ( - "sync" -) - -type Socket string -type Peer interface { - socket Socket - connection net.Conn -} - -func (p *Peer) Socket() Socket { - return p.socket -} - -// Router hash table to associate Socket with Peers. -// Unstructured mesh architecture -// eg. {127.0.0.1:4000: Peer} -type Router struct { - sync.RWMutex - table map[Socket]Peer -} - - -// Return connection interface based on socket -func (r *Router) Query(socket Socket) *Peer { - // Mutex for reading topics. - // Do not write while topics are read. - // Write Lock can’t be acquired until all Read Locks are released. - r.RWMutex.RLock() - defer r.RWMutex.RUnlock() - - if peer, ok := r.table[socket]; ok { - return peer - } - - return nil -} - -// Add create new socket connection association -func (r *Router) Add(peer *Peer) { - // Lock write table while add operation - // A blocked Lock call excludes new readers from acquiring the lock. - r.RWMutex.Lock() - defer r.RWMutex.Unlock() - r.table[peer.Socket()] = peer -} - -// Delete removes a connection from router -func (r *Router) Delete(peer *Peer) { - // Lock write table while delete operation - // A blocked Lock call excludes new readers from acquiring the lock. - r.RWMutex.Lock() - defer r.RWMutex.Unlock() - delete(r.table, peer.Socket()) -} -``` - -## Usage -### Syncronize routing peers from incoming connections - -```go - -// New router -router:= &Router{ - table: make(map[Socket]Peer) -} - -// !Important: -// 1 - Write Lock can’t be acquired until all Read Locks are released. -// 2 - A blocked Lock call excludes new readers from acquiring the lock. - -// Writing operation -go func(r *Router){ - for { - // this will be running waiting for new connections - /// .. some code here - conn, err := listener.Accept() - // eg. 192.168.1.1:8080 - remote := connection.RemoteAddr().String() - socket := Socket(address) - // New peer - peer := &Peer{ - socket: socket, - connection: conn - } - // Here we need a write lock to avoid race condition - r.Add(peer) - } -}(router) - -// Reading operation -go func(r *Router){ - // ...some logic here - // reading operation 1 - connection := r.Query("192.168.1.1:8080") - //... more code here - // reading operation 2 - otherQuery:= r.Query("192.168.1.1:8081") - // read locks are like counters.. until counter = 0 Write can be acquired -}(router) - -``` \ No newline at end of file From d7b6871ce8c0641535274b292cd4aa66c4afcb17 Mon Sep 17 00:00:00 2001 From: geolffreym Date: Fri, 10 Jun 2022 14:19:11 -0600 Subject: [PATCH 4/8] fix: rename file according to Summary --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 7d9f5f7..a115f2c 100644 --- a/README.md +++ b/README.md @@ -54,7 +54,7 @@ A curated collection of idiomatic design & application patterns for Go language. | [Condition Variable](/synchronization/condition_variable.md) | Provides a mechanism for threads to temporarily give up access in order to wait for some condition | ✘ | | [Lock/Mutex](/synchronization/mutex.md) | Enforces mutual exclusion limit on a resource to gain exclusive access | ✘ | | [Monitor](/synchronization/monitor.md) | Combination of mutex and condition variable patterns | ✘ | -| [Read-Write Lock](/synchronization/read_write_lock.md) | Allows parallel read access, but only exclusive access on write operations to a resource | ✘ | +| [Read-Write Lock](/synchronization/read_write_lock.md) | Allows parallel read access, but only exclusive access on write operations to a resource | ✔ | | [Semaphore](/synchronization/semaphore.md) | Allows controlling access to a common resource | ✔ | ## Concurrency Patterns From 097cfd05791cbe8928ed38e2dcd83ed4bf87e1b9 Mon Sep 17 00:00:00 2001 From: geolffreym Date: Fri, 10 Jun 2022 14:19:23 -0600 Subject: [PATCH 5/8] fix: rename file according to Summary --- synchronization/read_write_lock.md | 110 +++++++++++++++++++++++++++++ 1 file changed, 110 insertions(+) create mode 100644 synchronization/read_write_lock.md diff --git a/synchronization/read_write_lock.md b/synchronization/read_write_lock.md new file mode 100644 index 0000000..fbc6db2 --- /dev/null +++ b/synchronization/read_write_lock.md @@ -0,0 +1,110 @@ +# Read/Write Lock Pattern +Allows parallel read access, but only exclusive access on write operations to a resource + +## Implementation + +```go +package router + +import ( + "sync" +) + +type Socket string +type Peer interface { + socket Socket + connection net.Conn +} + +func (p *Peer) Socket() Socket { + return p.socket +} + +// Router hash table to associate Socket with Peers. +// Unstructured mesh architecture +// eg. {127.0.0.1:4000: Peer} +type Router struct { + sync.RWMutex + table map[Socket]Peer +} + + +// Return connection interface based on socket +func (r *Router) Query(socket Socket) *Peer { + // Mutex for reading topics. + // Do not write while topics are read. + // Write Lock can’t be acquired until all Read Locks are released. + r.RWMutex.RLock() + defer r.RWMutex.RUnlock() + + if peer, ok := r.table[socket]; ok { + return peer + } + + return nil +} + +// Add create new socket connection association +func (r *Router) Add(peer *Peer) { + // Lock write table while add operation + // A blocked Lock call excludes new readers from acquiring the lock. + r.RWMutex.Lock() + defer r.RWMutex.Unlock() + r.table[peer.Socket()] = peer +} + +// Delete removes a connection from router +func (r *Router) Delete(peer *Peer) { + // Lock write table while delete operation + // A blocked Lock call excludes new readers from acquiring the lock. + r.RWMutex.Lock() + defer r.RWMutex.Unlock() + delete(r.table, peer.Socket()) +} +``` + +## Usage +### Syncronize routing peers from incoming connections + +```go + +// New router +router:= &Router{ + table: make(map[Socket]Peer) +} + +// !Important: +// 1 - Write Lock can’t be acquired until all Read Locks are released. +// 2 - A blocked Lock call excludes new readers from acquiring the lock. + +// Writing operation +go func(r *Router){ + for { + // this will be running waiting for new connections + /// .. some code here + conn, err := listener.Accept() + // eg. 192.168.1.1:8080 + remote := connection.RemoteAddr().String() + socket := Socket(address) + // New peer + peer := &Peer{ + socket: socket, + connection: conn + } + // Here we need a write lock to avoid race condition + r.Add(peer) + } +}(router) + +// Reading operation +go func(r *Router){ + // ...some logic here + // reading operation 1 + connection := r.Query("192.168.1.1:8080") + //... more code here + // reading operation 2 + otherQuery:= r.Query("192.168.1.1:8081") + // read locks are like counters.. until counter = 0 Write can be acquired +}(router) + +``` \ No newline at end of file From 17e9b605521a12dc1634c24b5fe41e57283a6201 Mon Sep 17 00:00:00 2001 From: Geolffrey Mena Date: Fri, 10 Jun 2022 20:53:14 -0600 Subject: [PATCH 6/8] Update read_write_lock.md --- synchronization/read_write_lock.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/synchronization/read_write_lock.md b/synchronization/read_write_lock.md index fbc6db2..bb75d9f 100644 --- a/synchronization/read_write_lock.md +++ b/synchronization/read_write_lock.md @@ -49,8 +49,8 @@ func (r *Router) Add(peer *Peer) { // Lock write table while add operation // A blocked Lock call excludes new readers from acquiring the lock. r.RWMutex.Lock() - defer r.RWMutex.Unlock() r.table[peer.Socket()] = peer + r.RWMutex.Unlock() } // Delete removes a connection from router @@ -58,8 +58,8 @@ func (r *Router) Delete(peer *Peer) { // Lock write table while delete operation // A blocked Lock call excludes new readers from acquiring the lock. r.RWMutex.Lock() - defer r.RWMutex.Unlock() delete(r.table, peer.Socket()) + r.RWMutex.Unlock() } ``` @@ -107,4 +107,4 @@ go func(r *Router){ // read locks are like counters.. until counter = 0 Write can be acquired }(router) -``` \ No newline at end of file +``` From 29f2589e130f8bc9da4f491e43a51559a510b2af Mon Sep 17 00:00:00 2001 From: Geolffrey Mena Date: Fri, 10 Jun 2022 20:57:23 -0600 Subject: [PATCH 7/8] Update read_write_lock.md --- synchronization/read_write_lock.md | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/synchronization/read_write_lock.md b/synchronization/read_write_lock.md index bb75d9f..024d7ec 100644 --- a/synchronization/read_write_lock.md +++ b/synchronization/read_write_lock.md @@ -97,14 +97,14 @@ go func(r *Router){ }(router) // Reading operation -go func(r *Router){ - // ...some logic here - // reading operation 1 - connection := r.Query("192.168.1.1:8080") - //... more code here - // reading operation 2 - otherQuery:= r.Query("192.168.1.1:8081") - // read locks are like counters.. until counter = 0 Write can be acquired -}(router) +// ...some code here + +// reading operation 1 +connection := r.Query("192.168.1.1:8080") + +//... more code here +// reading operation 2 +otherQuery:= r.Query("192.168.1.1:8081") +// read locks are like counters.. until counter = 0 Write can be acquired ``` From 36b07a47657646aaf487ec94bead43bbb2d4a035 Mon Sep 17 00:00:00 2001 From: Geolffrey Mena Date: Fri, 10 Jun 2022 20:58:06 -0600 Subject: [PATCH 8/8] Update read_write_lock.md --- synchronization/read_write_lock.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/synchronization/read_write_lock.md b/synchronization/read_write_lock.md index 024d7ec..156236f 100644 --- a/synchronization/read_write_lock.md +++ b/synchronization/read_write_lock.md @@ -100,11 +100,11 @@ go func(r *Router){ // ...some code here // reading operation 1 -connection := r.Query("192.168.1.1:8080") +connection := router.Query("192.168.1.1:8080") //... more code here // reading operation 2 -otherQuery:= r.Query("192.168.1.1:8081") +otherQuery:= router.Query("192.168.1.1:8081") // read locks are like counters.. until counter = 0 Write can be acquired ```