diff --git a/src/context/benchmark_test.go b/src/context/benchmark_test.go
index 144f473a44..d10950d258 100644
--- a/src/context/benchmark_test.go
+++ b/src/context/benchmark_test.go
@@ -188,3 +188,23 @@ func BenchmarkDeepValueSameGoRoutine(b *testing.B) {
 		})
 	}
 }
+
+func BenchmarkErrOK(b *testing.B) {
+	ctx, cancel := WithCancel(Background())
+	defer cancel()
+	for b.Loop() {
+		if err := ctx.Err(); err != nil {
+			b.Fatalf("ctx.Err() = %v", err)
+		}
+	}
+}
+
+func BenchmarkErrCanceled(b *testing.B) {
+	ctx, cancel := WithCancel(Background())
+	cancel()
+	for b.Loop() {
+		if err := ctx.Err(); err == nil {
+			b.Fatalf("ctx.Err() = %v", err)
+		}
+	}
+}
diff --git a/src/context/context.go b/src/context/context.go
index bef9e8aab0..6020e2d310 100644
--- a/src/context/context.go
+++ b/src/context/context.go
@@ -428,7 +428,7 @@ type cancelCtx struct {
 	mu       sync.Mutex            // protects following fields
 	done     atomic.Value          // of chan struct{}, created lazily, closed by first cancel call
 	children map[canceler]struct{} // set to nil by the first cancel call
-	err      error                 // set to non-nil by the first cancel call
+	err      atomic.Value          // set to non-nil by the first cancel call
 	cause    error                 // set to non-nil by the first cancel call
 }
 
@@ -455,10 +455,11 @@ func (c *cancelCtx) Done() <-chan struct{} {
 }
 
 func (c *cancelCtx) Err() error {
-	c.mu.Lock()
-	err := c.err
-	c.mu.Unlock()
-	return err
+	// An atomic load is ~5x faster than a mutex, which can matter in tight loops.
+	if err := c.err.Load(); err != nil {
+		return err.(error)
+	}
+	return nil
 }
 
 // propagateCancel arranges for child to be canceled when parent is.
@@ -482,9 +483,9 @@ func (c *cancelCtx) propagateCancel(parent Context, child canceler) {
 	if p, ok := parentCancelCtx(parent); ok {
 		// parent is a *cancelCtx, or derives from one.
 		p.mu.Lock()
-		if p.err != nil {
+		if err := p.err.Load(); err != nil {
 			// parent has already been canceled
-			child.cancel(false, p.err, p.cause)
+			child.cancel(false, err.(error), p.cause)
 		} else {
 			if p.children == nil {
 				p.children = make(map[canceler]struct{})
@@ -545,11 +546,11 @@ func (c *cancelCtx) cancel(removeFromParent bool, err, cause error) {
 		cause = err
 	}
 	c.mu.Lock()
-	if c.err != nil {
+	if c.err.Load() != nil {
 		c.mu.Unlock()
 		return // already canceled
 	}
-	c.err = err
+	c.err.Store(err)
 	c.cause = cause
 	d, _ := c.done.Load().(chan struct{})
 	if d == nil {
@@ -639,7 +640,7 @@ func WithDeadlineCause(parent Context, d time.Time, cause error) (Context, Cance
 	}
 	c.mu.Lock()
 	defer c.mu.Unlock()
-	if c.err == nil {
+	if c.err.Load() == nil {
 		c.timer = time.AfterFunc(dur, func() {
 			c.cancel(true, DeadlineExceeded, cause)
 		})