Fix: Consistent threads capacity in Go tests

Author: ashvardanian

golang/README.md

@@ -84,9 +84,7 @@ func main() {
 }
 ```
 
-Notes:
-- Always call `Reserve(capacity)` before the first write.
-- Prefer single-caller writes with internal parallelism via `ChangeThreadsAdd` and internal parallel searches via `ChangeThreadsSearch`, instead of calling `Add` concurrently.
+Always call `Reserve(capacity)` before the first write.
 
 3. Get USearch:
 
@@ -184,3 +182,32 @@ keys, distances, err := usearch.ExactSearch(
     maxResults, 0,  // 0 threads = auto-detect
 )
 ```
+
+## Concurrency
+
+USearch supports concurrent operations from multiple goroutines. Use `ChangeThreadsAdd` and `ChangeThreadsSearch` to configure the number of concurrent operations allowed:
+
+```go
+err := index.ChangeThreadsAdd(8)	// Allow up to 8 concurrent additions
+err = index.ChangeThreadsSearch(16)	// Allow up to 16 concurrent searches
+```
+
+When using multiple goroutines, reserve at least as many threads as the number of concurrent callers:
+
+```go
+const numWorkers = 10
+
+// Reserve threads for concurrent searches
+_ = index.ChangeThreadsSearch(numWorkers)
+
+var wg sync.WaitGroup
+for i := 0; i < numWorkers; i++ {
+    wg.Add(1)
+    go func() {
+        defer wg.Done()
+        keys, distances, err := index.Search(queryVector, 10)
+        // ...
+    }()
+}
+wg.Wait()
+```

golang/lib_test.go

@@ -1,7 +1,7 @@
 package usearch
 
 import (
-	"fmt"
+	"errors"
 	"io"
 	"math"
 	"runtime"
@@ -786,16 +786,15 @@ func TestConcurrentSearches(t *testing.T) {
 		// Pre-populate with data
 		testVectors := populateIndex(t, index, 200)
 
-		// Let the library parallelize search internally as well
-		_ = index.ChangeThreadsSearch(uint(runtime.NumCPU()))
-
 		const numGoroutines = 30
 		const searchesPerGoroutine = 50
 
+		// Reserve enough threads for all concurrent search operations
+		_ = index.ChangeThreadsSearch(numGoroutines)
+
 		var wg sync.WaitGroup
-		errorChan := make(chan error, numGoroutines)
+		errChan := make(chan error, numGoroutines)
 
-		// Only concurrent searches - no mixed operations
 		for i := 0; i < numGoroutines; i++ {
 			wg.Add(1)
 			go func(goroutineID int) {
@@ -808,30 +807,30 @@ func TestConcurrentSearches(t *testing.T) {
 
 					keys, distances, err := index.Search(query, 10)
 					if err != nil {
-						errorChan <- err
+						errChan <- err
 						return
 					}
 
 					// Basic validation - should find at least the exact match
 					if len(keys) == 0 || len(distances) == 0 {
-						errorChan <- fmt.Errorf("search returned empty results")
+						errChan <- errors.New("search returned empty results")
 						return
 					}
 
 					// First result should be the exact match
 					if keys[0] != Key(queryIndex) || math.Abs(float64(distances[0])) > distanceTolerance {
-						errorChan <- fmt.Errorf("search results inconsistent: expected key %d, got %d", queryIndex, keys[0])
+						errChan <- errors.New("search results inconsistent")
 						return
 					}
 				}
 			}(i)
 		}
 
 		wg.Wait()
-		close(errorChan)
+		close(errChan)
 
 		// Check for any errors
-		for err := range errorChan {
+		for err := range errChan {
 			t.Fatalf("Concurrent search failed: %v", err)
 		}
 	})