<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Concurrency on 100 Exercises to Learn Go</title><link>https://hamzahraihan.github.io/100-exercises-to-learn-go/07_concurrency/</link><description>Recent content in Concurrency on 100 Exercises to Learn Go</description><generator>Hugo</generator><language>en</language><atom:link href="https://hamzahraihan.github.io/100-exercises-to-learn-go/07_concurrency/index.xml" rel="self" type="application/rss+xml"/><item><title>Mutex Counter</title><link>https://hamzahraihan.github.io/100-exercises-to-learn-go/07_concurrency/mutex/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://hamzahraihan.github.io/100-exercises-to-learn-go/07_concurrency/mutex/</guid><description>&lt;h1 id="mutex-counter"&gt;Mutex Counter&lt;a class="anchor" href="#mutex-counter"&gt;&lt;/a&gt;&lt;/h1&gt;
&lt;p&gt;One hundred goroutines, one integer, each adding one. The answer should be
100. Run the check and watch it come back 97, 99, 100 — a different wrong
number every time. This exercise is about why one innocent line can&amp;rsquo;t be
trusted, and the one lock that makes it trustworthy.&lt;/p&gt;
&lt;h2 id="one-step-that-is-three"&gt;One step that is three&lt;a class="anchor" href="#one-step-that-is-three"&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;div class="highlight"&gt;&lt;pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"&gt;&lt;code class="language-go" data-lang="go"&gt;&lt;span style="display:flex;"&gt;&lt;span&gt;&lt;span style="color:#a6e22e"&gt;c&lt;/span&gt;.&lt;span style="color:#a6e22e"&gt;n&lt;/span&gt; &lt;span style="color:#f92672"&gt;+=&lt;/span&gt; &lt;span style="color:#a6e22e"&gt;n&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;Reads as a single step. Compiles as three: load &lt;code&gt;c.n&lt;/code&gt; into a register, add
&lt;code&gt;n&lt;/code&gt;, store the result back. Two goroutines can interleave fatally — both
load 41, both add 1, both store 42 — and one increment vanishes without a
trace. No error, no panic, just a count that drifts downward under load.
Every shared-state bug in Go is some version of this interleaving.&lt;/p&gt;</description></item><item><title>Channel Pipeline</title><link>https://hamzahraihan.github.io/100-exercises-to-learn-go/07_concurrency/channels/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://hamzahraihan.github.io/100-exercises-to-learn-go/07_concurrency/channels/</guid><description>&lt;h1 id="channel-pipeline"&gt;Channel Pipeline&lt;a class="anchor" href="#channel-pipeline"&gt;&lt;/a&gt;&lt;/h1&gt;
&lt;p&gt;The mutex lesson shared state and guarded it. This one inverts the
strategy: don&amp;rsquo;t share the slice at all. Each input travels to its own
goroutine, each result travels back over a channel, and the output is
assembled where exactly one goroutine — the caller — ever touches it.&lt;/p&gt;
&lt;h2 id="sending-work-out-collecting-results-back"&gt;Sending work out, collecting results back&lt;a class="anchor" href="#sending-work-out-collecting-results-back"&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;div class="highlight"&gt;&lt;pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"&gt;&lt;code class="language-go" data-lang="go"&gt;&lt;span style="display:flex;"&gt;&lt;span&gt;&lt;span style="color:#75715e"&gt;// Syntax: make the channel, send with &amp;lt;-, receive with &amp;lt;-&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style="display:flex;"&gt;&lt;span&gt;&lt;span style="color:#a6e22e"&gt;ch&lt;/span&gt; &lt;span style="color:#f92672"&gt;:=&lt;/span&gt; make(&lt;span style="color:#66d9ef"&gt;chan&lt;/span&gt; &lt;span style="color:#66d9ef"&gt;int&lt;/span&gt;) &lt;span style="color:#75715e"&gt;// unbuffered: every send waits for a receiver&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style="display:flex;"&gt;&lt;span&gt;&lt;span style="color:#a6e22e"&gt;ch&lt;/span&gt; &lt;span style="color:#f92672"&gt;&amp;lt;-&lt;/span&gt; &lt;span style="color:#ae81ff"&gt;42&lt;/span&gt; &lt;span style="color:#75715e"&gt;// send (blocks until received)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style="display:flex;"&gt;&lt;span&gt;&lt;span style="color:#a6e22e"&gt;v&lt;/span&gt; &lt;span style="color:#f92672"&gt;:=&lt;/span&gt; &lt;span style="color:#f92672"&gt;&amp;lt;-&lt;/span&gt;&lt;span style="color:#a6e22e"&gt;ch&lt;/span&gt; &lt;span style="color:#75715e"&gt;// receive (blocks until sent)&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;A &lt;strong&gt;channel&lt;/strong&gt; is a typed conduit between goroutines. &lt;code&gt;go&lt;/code&gt; launches the
worker; the channel carries the answer home:&lt;/p&gt;</description></item><item><title>Buffered Collect</title><link>https://hamzahraihan.github.io/100-exercises-to-learn-go/07_concurrency/buffered/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://hamzahraihan.github.io/100-exercises-to-learn-go/07_concurrency/buffered/</guid><description>&lt;h1 id="buffered-collect"&gt;Buffered Collect&lt;a class="anchor" href="#buffered-collect"&gt;&lt;/a&gt;&lt;/h1&gt;
&lt;p&gt;The pipeline lesson&amp;rsquo;s channel was unbuffered: every send blocked until a
receiver arrived. Sender and collector moved in lockstep, each paced by the
other. Sometimes that&amp;rsquo;s exactly the backpressure you want. Here it isn&amp;rsquo;t —
&lt;code&gt;n&lt;/code&gt; workers shouldn&amp;rsquo;t queue behind one drain. This exercise gives the
channel a waiting room.&lt;/p&gt;
&lt;h2 id="unbuffered-is-a-handshake"&gt;Unbuffered is a handshake&lt;a class="anchor" href="#unbuffered-is-a-handshake"&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;div class="highlight"&gt;&lt;pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"&gt;&lt;code class="language-go" data-lang="go"&gt;&lt;span style="display:flex;"&gt;&lt;span&gt;&lt;span style="color:#a6e22e"&gt;ch&lt;/span&gt; &lt;span style="color:#f92672"&gt;:=&lt;/span&gt; make(&lt;span style="color:#66d9ef"&gt;chan&lt;/span&gt; &lt;span style="color:#66d9ef"&gt;int&lt;/span&gt;) &lt;span style="color:#75715e"&gt;// capacity 0: send waits for receive, and vice versa&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;Every value changes hands directly, sender to receiver, in the same
instant. Elegant — and coupled: a fast worker idles until the collector
asks, a slow collector stalls every worker behind the current one. For
one-to-one rhythms that&amp;rsquo;s fine. For fan-out, it&amp;rsquo;s a traffic jam with extra
steps.&lt;/p&gt;</description></item><item><title>Select with Timeout</title><link>https://hamzahraihan.github.io/100-exercises-to-learn-go/07_concurrency/select/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://hamzahraihan.github.io/100-exercises-to-learn-go/07_concurrency/select/</guid><description>&lt;h1 id="select-with-timeout"&gt;Select with Timeout&lt;a class="anchor" href="#select-with-timeout"&gt;&lt;/a&gt;&lt;/h1&gt;
&lt;p&gt;Channels so far had one conversation each: send, receive, done. Real
programs juggle — data arriving &lt;em&gt;or&lt;/em&gt; a deadline expiring, whichever comes
first. Waiting on one channel while another fires is how fetches hang
forever. &lt;code&gt;select&lt;/code&gt; is how they don&amp;rsquo;t.&lt;/p&gt;
&lt;h2 id="waiting-on-whichever-answers-first"&gt;Waiting on whichever answers first&lt;a class="anchor" href="#waiting-on-whichever-answers-first"&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;div class="highlight"&gt;&lt;pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"&gt;&lt;code class="language-go" data-lang="go"&gt;&lt;span style="display:flex;"&gt;&lt;span&gt;&lt;span style="color:#75715e"&gt;// Syntax: select runs the first ready case, blocking until one is&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style="display:flex;"&gt;&lt;span&gt;&lt;span style="color:#66d9ef"&gt;select&lt;/span&gt; {
&lt;/span&gt;&lt;/span&gt;&lt;span style="display:flex;"&gt;&lt;span&gt;&lt;span style="color:#66d9ef"&gt;case&lt;/span&gt; &lt;span style="color:#a6e22e"&gt;v&lt;/span&gt; &lt;span style="color:#f92672"&gt;:=&lt;/span&gt; &lt;span style="color:#f92672"&gt;&amp;lt;-&lt;/span&gt;&lt;span style="color:#a6e22e"&gt;dataCh&lt;/span&gt;:
&lt;/span&gt;&lt;/span&gt;&lt;span style="display:flex;"&gt;&lt;span&gt; &lt;span style="color:#75715e"&gt;// data arrived first&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style="display:flex;"&gt;&lt;span&gt;&lt;span style="color:#66d9ef"&gt;case&lt;/span&gt; &lt;span style="color:#f92672"&gt;&amp;lt;-&lt;/span&gt;&lt;span style="color:#a6e22e"&gt;time&lt;/span&gt;.&lt;span style="color:#a6e22e"&gt;After&lt;/span&gt;(&lt;span style="color:#ae81ff"&gt;200&lt;/span&gt; &lt;span style="color:#f92672"&gt;*&lt;/span&gt; &lt;span style="color:#a6e22e"&gt;time&lt;/span&gt;.&lt;span style="color:#a6e22e"&gt;Millisecond&lt;/span&gt;):
&lt;/span&gt;&lt;/span&gt;&lt;span style="display:flex;"&gt;&lt;span&gt; &lt;span style="color:#75715e"&gt;// deadline hit first&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style="display:flex;"&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;&lt;code&gt;select&lt;/code&gt; blocks until &lt;strong&gt;one&lt;/strong&gt; of its cases can proceed, then runs exactly
that case. It reads like &lt;code&gt;switch&lt;/code&gt;, but the branches are channel operations
and the condition is &lt;em&gt;readiness&lt;/em&gt;, not equality. If several cases are ready
simultaneously, one is picked at random — fairness by design, so study the
implication: never write cases whose correctness depends on priority order.&lt;/p&gt;</description></item><item><title>Worker Pool</title><link>https://hamzahraihan.github.io/100-exercises-to-learn-go/07_concurrency/worker_pool/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://hamzahraihan.github.io/100-exercises-to-learn-go/07_concurrency/worker_pool/</guid><description>&lt;h1 id="worker-pool"&gt;Worker Pool&lt;a class="anchor" href="#worker-pool"&gt;&lt;/a&gt;&lt;/h1&gt;
&lt;p&gt;Fan-out/fan-in is Go&amp;rsquo;s workhorse concurrency pattern. Raw goroutine-per-item works
until it doesn&amp;rsquo;t — 10 000 goroutines each doing I/O will crush the OS scheduler and
exhaust file descriptors long before they finish. A &lt;strong&gt;worker pool&lt;/strong&gt; caps parallelism
at a fixed number while an unbounded queue of jobs keeps feeding them.&lt;/p&gt;
&lt;h2 id="the-shape"&gt;The shape&lt;a class="anchor" href="#the-shape"&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;div class="highlight"&gt;&lt;pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"&gt;&lt;code class="language-go" data-lang="go"&gt;&lt;span style="display:flex;"&gt;&lt;span&gt;&lt;span style="color:#a6e22e"&gt;jobs&lt;/span&gt; &lt;span style="color:#f92672"&gt;:=&lt;/span&gt; make(&lt;span style="color:#66d9ef"&gt;chan&lt;/span&gt; &lt;span style="color:#66d9ef"&gt;int&lt;/span&gt;, len(&lt;span style="color:#a6e22e"&gt;inputs&lt;/span&gt;))
&lt;/span&gt;&lt;/span&gt;&lt;span style="display:flex;"&gt;&lt;span&gt;&lt;span style="color:#a6e22e"&gt;results&lt;/span&gt; &lt;span style="color:#f92672"&gt;:=&lt;/span&gt; make(&lt;span style="color:#66d9ef"&gt;chan&lt;/span&gt; &lt;span style="color:#66d9ef"&gt;int&lt;/span&gt;, len(&lt;span style="color:#a6e22e"&gt;inputs&lt;/span&gt;))
&lt;/span&gt;&lt;/span&gt;&lt;span style="display:flex;"&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style="display:flex;"&gt;&lt;span&gt;&lt;span style="color:#66d9ef"&gt;for&lt;/span&gt; &lt;span style="color:#a6e22e"&gt;w&lt;/span&gt; &lt;span style="color:#f92672"&gt;:=&lt;/span&gt; &lt;span style="color:#ae81ff"&gt;0&lt;/span&gt;; &lt;span style="color:#a6e22e"&gt;w&lt;/span&gt; &amp;lt; &lt;span style="color:#a6e22e"&gt;workers&lt;/span&gt;; &lt;span style="color:#a6e22e"&gt;w&lt;/span&gt;&lt;span style="color:#f92672"&gt;++&lt;/span&gt; {
&lt;/span&gt;&lt;/span&gt;&lt;span style="display:flex;"&gt;&lt;span&gt; &lt;span style="color:#66d9ef"&gt;go&lt;/span&gt; &lt;span style="color:#66d9ef"&gt;func&lt;/span&gt;() {
&lt;/span&gt;&lt;/span&gt;&lt;span style="display:flex;"&gt;&lt;span&gt; &lt;span style="color:#66d9ef"&gt;for&lt;/span&gt; &lt;span style="color:#a6e22e"&gt;j&lt;/span&gt; &lt;span style="color:#f92672"&gt;:=&lt;/span&gt; &lt;span style="color:#66d9ef"&gt;range&lt;/span&gt; &lt;span style="color:#a6e22e"&gt;jobs&lt;/span&gt; {
&lt;/span&gt;&lt;/span&gt;&lt;span style="display:flex;"&gt;&lt;span&gt; &lt;span style="color:#a6e22e"&gt;results&lt;/span&gt; &lt;span style="color:#f92672"&gt;&amp;lt;-&lt;/span&gt; &lt;span style="color:#a6e22e"&gt;j&lt;/span&gt; &lt;span style="color:#f92672"&gt;*&lt;/span&gt; &lt;span style="color:#a6e22e"&gt;j&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style="display:flex;"&gt;&lt;span&gt; }
&lt;/span&gt;&lt;/span&gt;&lt;span style="display:flex;"&gt;&lt;span&gt; }()
&lt;/span&gt;&lt;/span&gt;&lt;span style="display:flex;"&gt;&lt;span&gt;}
&lt;/span&gt;&lt;/span&gt;&lt;span style="display:flex;"&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style="display:flex;"&gt;&lt;span&gt;&lt;span style="color:#66d9ef"&gt;for&lt;/span&gt; &lt;span style="color:#a6e22e"&gt;_&lt;/span&gt;, &lt;span style="color:#a6e22e"&gt;v&lt;/span&gt; &lt;span style="color:#f92672"&gt;:=&lt;/span&gt; &lt;span style="color:#66d9ef"&gt;range&lt;/span&gt; &lt;span style="color:#a6e22e"&gt;inputs&lt;/span&gt; {
&lt;/span&gt;&lt;/span&gt;&lt;span style="display:flex;"&gt;&lt;span&gt; &lt;span style="color:#a6e22e"&gt;jobs&lt;/span&gt; &lt;span style="color:#f92672"&gt;&amp;lt;-&lt;/span&gt; &lt;span style="color:#a6e22e"&gt;v&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style="display:flex;"&gt;&lt;span&gt;}
&lt;/span&gt;&lt;/span&gt;&lt;span style="display:flex;"&gt;&lt;span&gt;close(&lt;span style="color:#a6e22e"&gt;jobs&lt;/span&gt;)
&lt;/span&gt;&lt;/span&gt;&lt;span style="display:flex;"&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style="display:flex;"&gt;&lt;span&gt;&lt;span style="color:#66d9ef"&gt;for&lt;/span&gt; &lt;span style="color:#66d9ef"&gt;range&lt;/span&gt; &lt;span style="color:#a6e22e"&gt;inputs&lt;/span&gt; {
&lt;/span&gt;&lt;/span&gt;&lt;span style="display:flex;"&gt;&lt;span&gt; &lt;span style="color:#a6e22e"&gt;_&lt;/span&gt; = &lt;span style="color:#f92672"&gt;&amp;lt;-&lt;/span&gt;&lt;span style="color:#a6e22e"&gt;results&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style="display:flex;"&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;Two channels carry all the work:&lt;/p&gt;</description></item><item><title>Context and Cancellation</title><link>https://hamzahraihan.github.io/100-exercises-to-learn-go/07_concurrency/context/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://hamzahraihan.github.io/100-exercises-to-learn-go/07_concurrency/context/</guid><description>&lt;h1 id="context-and-cancellation"&gt;Context and Cancellation&lt;a class="anchor" href="#context-and-cancellation"&gt;&lt;/a&gt;&lt;/h1&gt;
&lt;p&gt;Goroutines are cheap to start and expensive to forget. Every goroutine that
blocks on I/O, a channel, or a sleep without a stop signal is a goroutine you
cannot reclaim. &lt;code&gt;context.Context&lt;/code&gt; is Go&amp;rsquo;s first-class cancellation token —
passed explicitly, checked at every blocking point.&lt;/p&gt;
&lt;h2 id="the-context-tree"&gt;The context tree&lt;a class="anchor" href="#the-context-tree"&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;div class="highlight"&gt;&lt;pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"&gt;&lt;code class="language-go" data-lang="go"&gt;&lt;span style="display:flex;"&gt;&lt;span&gt;&lt;span style="color:#a6e22e"&gt;ctx&lt;/span&gt;, &lt;span style="color:#a6e22e"&gt;cancel&lt;/span&gt; &lt;span style="color:#f92672"&gt;:=&lt;/span&gt; &lt;span style="color:#a6e22e"&gt;context&lt;/span&gt;.&lt;span style="color:#a6e22e"&gt;WithTimeout&lt;/span&gt;(&lt;span style="color:#a6e22e"&gt;context&lt;/span&gt;.&lt;span style="color:#a6e22e"&gt;Background&lt;/span&gt;(), &lt;span style="color:#ae81ff"&gt;2&lt;/span&gt;&lt;span style="color:#f92672"&gt;*&lt;/span&gt;&lt;span style="color:#a6e22e"&gt;time&lt;/span&gt;.&lt;span style="color:#a6e22e"&gt;Second&lt;/span&gt;)
&lt;/span&gt;&lt;/span&gt;&lt;span style="display:flex;"&gt;&lt;span&gt;&lt;span style="color:#66d9ef"&gt;defer&lt;/span&gt; &lt;span style="color:#a6e22e"&gt;cancel&lt;/span&gt;() &lt;span style="color:#75715e"&gt;// always defer — releases resources even if timeout fires first&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;&lt;code&gt;Background()&lt;/code&gt; is the root; &lt;code&gt;WithTimeout&lt;/code&gt;/&lt;code&gt;WithCancel&lt;/code&gt;/&lt;code&gt;WithDeadline&lt;/code&gt; derive
children. Cancel a parent and every child is cancelled. Defer cancel
unconditionally — leaving it out leaks a timer goroutine for the full timeout
duration even if the work finishes early.&lt;/p&gt;</description></item><item><title>Read/Write Mutex</title><link>https://hamzahraihan.github.io/100-exercises-to-learn-go/07_concurrency/rwmutex/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://hamzahraihan.github.io/100-exercises-to-learn-go/07_concurrency/rwmutex/</guid><description>&lt;h1 id="readwrite-mutex"&gt;Read/Write Mutex&lt;a class="anchor" href="#readwrite-mutex"&gt;&lt;/a&gt;&lt;/h1&gt;
&lt;p&gt;The mutex lesson put one lock on everything. That&amp;rsquo;s safe, but heavy: reads can&amp;rsquo;t race each other — only a read-write conflict is dangerous. When reads dominate (a cache hit ratio of 99%), locking out every concurrent reader is waste. &lt;code&gt;sync.RWMutex&lt;/code&gt; splits the lock in two.&lt;/p&gt;
&lt;h2 id="the-two-locks"&gt;The two locks&lt;a class="anchor" href="#the-two-locks"&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;div class="highlight"&gt;&lt;pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"&gt;&lt;code class="language-go" data-lang="go"&gt;&lt;span style="display:flex;"&gt;&lt;span&gt;&lt;span style="color:#66d9ef"&gt;var&lt;/span&gt; &lt;span style="color:#a6e22e"&gt;mu&lt;/span&gt; &lt;span style="color:#a6e22e"&gt;sync&lt;/span&gt;.&lt;span style="color:#a6e22e"&gt;RWMutex&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style="display:flex;"&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style="display:flex;"&gt;&lt;span&gt;&lt;span style="color:#75715e"&gt;// Readers: many can hold this at once&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style="display:flex;"&gt;&lt;span&gt;&lt;span style="color:#a6e22e"&gt;mu&lt;/span&gt;.&lt;span style="color:#a6e22e"&gt;RLock&lt;/span&gt;()
&lt;/span&gt;&lt;/span&gt;&lt;span style="display:flex;"&gt;&lt;span&gt;&lt;span style="color:#66d9ef"&gt;defer&lt;/span&gt; &lt;span style="color:#a6e22e"&gt;mu&lt;/span&gt;.&lt;span style="color:#a6e22e"&gt;RUnlock&lt;/span&gt;()
&lt;/span&gt;&lt;/span&gt;&lt;span style="display:flex;"&gt;&lt;span&gt;&lt;span style="color:#a6e22e"&gt;v&lt;/span&gt; &lt;span style="color:#f92672"&gt;:=&lt;/span&gt; &lt;span style="color:#a6e22e"&gt;cache&lt;/span&gt;[&lt;span style="color:#a6e22e"&gt;key&lt;/span&gt;]
&lt;/span&gt;&lt;/span&gt;&lt;span style="display:flex;"&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style="display:flex;"&gt;&lt;span&gt;&lt;span style="color:#75715e"&gt;// Writers: exclusive; waits for all readers to finish&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style="display:flex;"&gt;&lt;span&gt;&lt;span style="color:#a6e22e"&gt;mu&lt;/span&gt;.&lt;span style="color:#a6e22e"&gt;Lock&lt;/span&gt;()
&lt;/span&gt;&lt;/span&gt;&lt;span style="display:flex;"&gt;&lt;span&gt;&lt;span style="color:#66d9ef"&gt;defer&lt;/span&gt; &lt;span style="color:#a6e22e"&gt;mu&lt;/span&gt;.&lt;span style="color:#a6e22e"&gt;Unlock&lt;/span&gt;()
&lt;/span&gt;&lt;/span&gt;&lt;span style="display:flex;"&gt;&lt;span&gt;&lt;span style="color:#a6e22e"&gt;cache&lt;/span&gt;[&lt;span style="color:#a6e22e"&gt;key&lt;/span&gt;] = &lt;span style="color:#a6e22e"&gt;value&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;&lt;code&gt;RLock&lt;/code&gt; grants shared access; many goroutines may hold it simultaneously. &lt;code&gt;Lock&lt;/code&gt; waits until every &lt;code&gt;RLock&lt;/code&gt; is released, then blocks all new &lt;code&gt;RLock&lt;/code&gt; calls. The invariant: a writer is never concurrent with anyone. A reader is never concurrent with a writer. Two readers are fine.&lt;/p&gt;</description></item></channel></rss>