Use sync.Pool for go1.3 and up

This has the additional benefit of removing the need for a go1.3 branch.

web/chanpool.go

@@ -0,0 +1,31 @@
+// +build !go1.3
+
+package web
+
+// This is an alternate implementation of Go 1.3's sync.Pool.
+
+// Maximum size of the pool of spare middleware stacks
+const cPoolSize = 32
+
+type cPool chan *cStack
+
+func makeCPool() *cPool {
+	var p cPool = make(chan *cStack, cPoolSize)
+	return &p
+}
+
+func (c cPool) alloc() *cStack {
+	select {
+	case cs := <-c:
+		return cs
+	default:
+		return nil
+	}
+}
+
+func (c cPool) release(cs *cStack) {
+	select {
+	case c <- cs:
+	default:
+	}
+}

web/cpool.go

@@ -0,0 +1,24 @@
+// +build go1.3
+
+package web
+
+import "sync"
+
+type cPool sync.Pool
+
+func makeCPool() *cPool {
+	return &cPool{}
+}
+
+func (c *cPool) alloc() *cStack {
+	cs := (*sync.Pool)(c).Get()
+	if cs == nil {
+		return nil
+	} else {
+		return cs.(*cStack)
+	}
+}
+
+func (c *cPool) release(cs *cStack) {
+	(*sync.Pool)(c).Put(cs)
+}

web/middleware.go

@@ -7,9 +7,6 @@ import (
 	"sync"
 )
 
-// Maximum size of the pool of spare middleware stacks
-const mPoolSize = 32
-
 type mLayer struct {
 	fn   func(*C, http.Handler) http.Handler
 	orig interface{}
@@ -18,7 +15,7 @@ type mLayer struct {
 type mStack struct {
 	lock   sync.Mutex
 	stack  []mLayer
-	pool   chan *cStack
+	pool   *cPool
 	router internalRouter
 }
 
@@ -46,7 +43,7 @@ cStack on the floor.
 type cStack struct {
 	C
 	m    http.Handler
-	pool chan *cStack
+	pool *cPool
 }
 
 func (s *cStack) ServeHTTP(w http.ResponseWriter, r *http.Request) {
@@ -86,7 +83,7 @@ func (m *mStack) findLayer(l interface{}) int {
 }
 
 func (m *mStack) invalidate() {
-	m.pool = make(chan *cStack, mPoolSize)
+	m.pool = makeCPool()
 }
 
 func (m *mStack) newStack() *cStack {
@@ -112,16 +109,8 @@ func (m *mStack) alloc() *cStack {
 	// sync/atomic, but for now I happen to know that on all the
 	// architectures I care about it happens to be atomic.
 	p := m.pool
-	var cs *cStack
-	select {
-	case cs = <-p:
-		// This can happen if we race against an invalidation. It's
-		// completely peaceful, so long as we assume we can grab a cStack before
-		// our stack blows out.
-		if cs == nil {
-			return m.alloc()
-		}
-	default:
+	cs := p.alloc()
+	if cs == nil {
 		cs = m.newStack()
 	}
 
@@ -134,10 +123,8 @@ func (m *mStack) release(cs *cStack) {
 	if cs.pool != m.pool {
 		return
 	}
-	select {
-	case cs.pool <- cs:
-	default:
-	}
+	cs.pool.release(cs)
+	cs.pool = nil
 }
 
 // Append the given middleware to the middleware stack. See the documentation

web/middleware_test.go

@@ -19,7 +19,7 @@ func makeStack(ch chan string) *mStack {
 	}
 	return &mStack{
 		stack:  make([]mLayer, 0),
-		pool:   make(chan *cStack, mPoolSize),
+		pool:   makeCPool(),
 		router: iRouter(router),
 	}
 }
@@ -215,7 +215,7 @@ func TestContext(t *testing.T) {
 	}
 	st := mStack{
 		stack:  make([]mLayer, 0),
-		pool:   make(chan *cStack, mPoolSize),
+		pool:   makeCPool(),
 		router: iRouter(router),
 	}
 	st.Use(func(c *C, h http.Handler) http.Handler {

web/mux.go

@@ -61,7 +61,7 @@ func New() *Mux {
 	mux := Mux{
 		mStack: mStack{
 			stack: make([]mLayer, 0),
-			pool:  make(chan *cStack, mPoolSize),
+			pool:  makeCPool(),
 		},
 		router: router{
 			routes:   make([]route, 0),