golang mgo的mongo连接池设置：必须手动加上maxPoolSize

GlobalMgoSession, err := mgo.Dial(host)   func (m *MongoBaseDao) Get(tablename string, id string, result interface{}) interface{} {     session := GlobalMgoSession.Clone()     defer session.Close()       collection := session.DB(globalMgoDbName).C(tablename)     err := collection.FindId(bson.ObjectIdHex(id)).One(result)       if err != nil {         logkit.Logger.Error("mongo_base method:Get " + err.Error())     }     return result }

// Clone works just like Copy, but also reuses the same socket as the original // session, in case it had already reserved one due to its consistency // guarantees.  This behavior ensures that writes performed in the old session // are necessarily observed when using the new session, as long as it was a // strong or monotonic session.  That said, it also means that long operations // may cause other goroutines using the original session to wait. func (s *Session) Clone() *Session {     s.m.Lock()     scopy := copySession(s, true)     s.m.Unlock()     return scopy }     // Close terminates the session.  It's a runtime error to use a session // after it has been closed. func (s *Session) Close() {     s.m.Lock()     if s.cluster_ != nil {         debugf("Closing session %p", s)         s.unsetSocket()  //释放当前线程占用的socket 置为nil         s.cluster_.Release()         s.cluster_ = nil     }     s.m.Unlock() }

func (s *Session) acquireSocket(slaveOk bool) (*mongoSocket, error) {     // Read-only lock to check for previously reserved socket.     s.m.RLock()     // If there is a slave socket reserved and its use is acceptable, take it as long     // as there isn't a master socket which would be preferred by the read preference mode.     if s.slaveSocket != nil && s.slaveOk && slaveOk && (s.masterSocket == nil || s.consistency != PrimaryPreferred && s.consistency != Monotonic) {         socket := s.slaveSocket         socket.Acquire()         s.m.RUnlock()         logkit.Logger.Info("sgp_test 1 acquireSocket slave is ok!")         return socket, nil     }     if s.masterSocket != nil {         socket := s.masterSocket         socket.Acquire()         s.m.RUnlock()         logkit.Logger.Info("sgp_test 1  acquireSocket master is ok!")         return socket, nil     }       s.m.RUnlock()       // No go.  We may have to request a new socket and change the session,     // so try again but with an exclusive lock now.     s.m.Lock()     defer s.m.Unlock()     if s.slaveSocket != nil && s.slaveOk && slaveOk && (s.masterSocket == nil || s.consistency != PrimaryPreferred && s.consistency != Monotonic) {         s.slaveSocket.Acquire()         logkit.Logger.Info("sgp_test 2  acquireSocket slave is ok!")         return s.slaveSocket, nil     }     if s.masterSocket != nil {         s.masterSocket.Acquire()         logkit.Logger.Info("sgp_test 2  acquireSocket master is ok!")         return s.masterSocket, nil     }       // Still not good.  We need a new socket.     sock, err := s.cluster().AcquireSocket(s.consistency, slaveOk && s.slaveOk, s.syncTimeout, s.sockTimeout, s.queryConfig.op.serverTags, s.poolLimit)   ......     logkit.Logger.Info("sgp_test 3   acquireSocket cluster AcquireSocket is ok!")     return sock, nil   }

Mar 25 09:46:40 dev02.pandatv.com bikini[12607]:  [info] sgp_test 1  acquireSocket master is ok! Mar 25 09:46:40 dev02.pandatv.com bikini[12607]:  [info] sgp_test 1  acquireSocket master is ok! Mar 25 09:46:41 dev02.pandatv.com bikini[12607]:  [info] sgp_test 1 acquireSocket slave is ok! Mar 25 09:46:41 dev02.pandatv.com bikini[12607]:  [info] sgp_test 3   acquireSocket cluster AcquireSocket is ok! Mar 25 09:46:41 dev02.pandatv.com bikini[12607]:  [info] sgp_test 3   acquireSocket cluster AcquireSocket is ok! Mar 25 09:46:41 dev02.pandatv.com bikini[12607]:  [info] sgp_test 3   acquireSocket cluster AcquireSocket is ok!

src/gopkg.in/mgo.v2/cluster.go      s, abended, err := server.AcquireSocket(poolLimit, socketTimeout)         if err == errPoolLimit {             if !warnedLimit {                 warnedLimit = true                 logkit.Logger.Error("sgp_test WARNING: Per-server connection limit reached. " + err.Error())                 log("WARNING: Per-server connection limit reached.")             }             time.Sleep(100 * time.Millisecond)             continue         }   session.go: // SetPoolLimit sets the maximum number of sockets in use in a single server   // before this session will block waiting for a socket to be available.   // The default limit is 4096.   //   // This limit must be set to cover more than any expected workload of the   // application. It is a bad practice and an unsupported use case to use the   // database driver to define the concurrency limit of an application. Prevent   // such concurrency "at the door" instead, by properly restricting the amount   // of used resources and number of goroutines before they are created.   func (s *Session) SetPoolLimit(limit int) {       s.m.Lock()       s.poolLimit = limit       s.m.Unlock()   }