Clarify that Batch is only useful with concurrency

Author: tv42

README.md

@@ -139,11 +139,14 @@ err := db.Batch(func(tx *bolt.Tx) error {
 })
 ```
 
-Batch calls are opportunistically combined into larger transactions.
-The trade-off is that `Batch` can call the given function multiple
-times, if parts of the transaction fail. The function must be
-idempotent and side effects must take effect only after a successful
-return from `DB.Batch()`.
+Concurrent Batch calls are opportunistically combined into larger
+transactions. Batch is only useful when there are multiple goroutines
+calling it.
+
+The trade-off is that `Batch` can call the given
+function multiple times, if parts of the transaction fail. The
+function must be idempotent and side effects must take effect only
+after a successful return from `DB.Batch()`.
 
 For example: don't display messages from inside the function, instead
 set variables in the enclosing scope:

batch.go

@@ -10,15 +10,17 @@ import (
 // Batch calls fn as part of a batch. It behaves similar to Update,
 // except:
 //
-// 1. multiple Batch function calls can be combined into a single
-// Bolt transaction.
+// 1. concurrent Batch calls can be combined into a single Bolt
+// transaction.
 //
 // 2. the function passed to Batch may be called multiple times,
 // regardless of whether it returns error or not.
 //
 // This means that Batch function side effects must be idempotent and
 // take permanent effect only after a successful return is seen in
 // caller.
+//
+// Batch is only useful when there are multiple goroutines calling it.
 func (db *DB) Batch(fn func(*Tx) error) error {
 	errCh := make(chan error, 1)